diff --git a/.github/workflows/.gitkeep b/.github/workflows/.gitkeep new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml new file mode 100644 index 0000000000000000000000000000000000000000..16d7508b117424e02225e79152555cc0a4f6b4b1 --- /dev/null +++ b/.github/workflows/deploy.yml @@ -0,0 +1,39 @@ +# .github/workflows/deploy.yml +name: CI/CD Pipeline + +on: + push: + branches: + - main + +jobs: + build-and-deploy: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v3 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: "3.10" + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements.txt + + - name: Run tests + run: | + echo "✅ Add Pytest or other checks here" + + - name: Build Docker image + run: docker build -t llm-campaign-app . + + # Optional: Push to DockerHub/GHCR (needs secrets configured) + # - name: Push Docker Image + # run: | + # echo "${{ secrets.DOCKERHUB_PASSWORD }}" | docker login -u "${{ secrets.DOCKERHUB_USERNAME }}" --password-stdin + # docker tag llm-campaign-app your-dockerhub-user/llm-campaign-app + # docker push your-dockerhub-user/llm-campaign-app diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..8ee405550cae94e7e230804251af55fdb6c75e3e --- /dev/null +++ b/Dockerfile @@ -0,0 +1,22 @@ +# Dockerfile +FROM python:3.10-slim + +# Set working directory +WORKDIR /app + +# Copy project files +COPY . . + +# Install system dependencies (if needed) +RUN apt-get update && apt-get install -y \ + build-essential \ + && rm -rf /var/lib/apt/lists/* + +# Install Python dependencies +RUN pip install --no-cache-dir -r requirements.txt + +# Expose FastAPI port +EXPOSE 8000 + +# Run FastAPI app (backend) +CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"] diff --git a/__pycache__/app.cpython-310.pyc b/__pycache__/app.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d313117c649537fab5c79465804b45bc4c2dd194 Binary files /dev/null and b/__pycache__/app.cpython-310.pyc differ diff --git a/__pycache__/app.cpython-37.pyc b/__pycache__/app.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..67f1ee70124f3c908b9730fffe61f9705318dd67 Binary files /dev/null and b/__pycache__/app.cpython-37.pyc differ diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..b9f97d9e280c2689b79a1e28280efc96b3253d97 --- /dev/null +++ b/app.py @@ -0,0 +1,33 @@ +# backend/main.py +from fastapi import FastAPI, HTTPException +from pydantic import BaseModel +from src.marketingCampaignGen.components.model.predictor import LLMPredictionPipeline + + +app = FastAPI(title="Marketing Campaign Generator") + +# Define request schema +class ProductRequest(BaseModel): + product_name: str + features: list[str] + brand: str + audience: str + tone: str + goal: str +@app.get("/") +def read_root(): + return {"message": "Welcome to the Marketing Campaign Generator API!"} + +@app.post("/generate") +def generate_campaign(data: ProductRequest): + try: + predictor = LLMPredictionPipeline() + result = predictor.predict(data.dict()) + + + return {"campaign": result} + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) +if __name__ == "__main__": + import uvicorn + uvicorn.run("app:app", host="127.0.0.1", port=8000, reload=True) diff --git a/config/config.yaml b/config/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/main.py b/main.py new file mode 100644 index 0000000000000000000000000000000000000000..9c263165a391e7f6186c7a052ec385aedc8d9dd0 --- /dev/null +++ b/main.py @@ -0,0 +1,29 @@ +import subprocess + +def generate_with_ollama(prompt: str, model_name="mistral") -> str: + try: + # Run the ollama model using subprocess and pass the prompt via echo + result = subprocess.run( + ["ollama", "run", model_name], + input=prompt.encode(), + capture_output=True, + timeout=300 + + ) + + if result.returncode != 0: + raise RuntimeError(f"Ollama returned error: {result.stderr.decode()}") + + return result.stdout.decode().strip() + + except Exception as e: + return f"[Error] Failed to generate content: {e}" + + +# Example usage +if __name__ == "__main__": + sample_prompt = "Generate a friendly marketing ad for an eco-friendly water bottle that keeps water cold for 24 hours." + print("[Campaign Generator] Sending prompt to Ollama...") + output = generate_with_ollama(sample_prompt) + print("\n[Generated Campaign]") + print(output) diff --git a/marketing/.nonadmin b/marketing/.nonadmin new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/marketing/LICENSE_PYTHON.txt b/marketing/LICENSE_PYTHON.txt new file mode 100644 index 0000000000000000000000000000000000000000..4d64e0ba3d16cb65975da4610209ed8226b7dfed --- /dev/null +++ b/marketing/LICENSE_PYTHON.txt @@ -0,0 +1,279 @@ +A. HISTORY OF THE SOFTWARE +========================== + +Python was created in the early 1990s by Guido van Rossum at Stichting +Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands +as a successor of a language called ABC. Guido remains Python's +principal author, although it includes many contributions from others. + +In 1995, Guido continued his work on Python at the Corporation for +National Research Initiatives (CNRI, see http://www.cnri.reston.va.us) +in Reston, Virginia where he released several versions of the +software. + +In May 2000, Guido and the Python core development team moved to +BeOpen.com to form the BeOpen PythonLabs team. In October of the same +year, the PythonLabs team moved to Digital Creations, which became +Zope Corporation. In 2001, the Python Software Foundation (PSF, see +https://www.python.org/psf/) was formed, a non-profit organization +created specifically to own Python-related Intellectual Property. +Zope Corporation was a sponsoring member of the PSF. + +All Python releases are Open Source (see http://www.opensource.org for +the Open Source Definition). Historically, most, but not all, Python +releases have also been GPL-compatible; the table below summarizes +the various releases. + + Release Derived Year Owner GPL- + from compatible? (1) + + 0.9.0 thru 1.2 1991-1995 CWI yes + 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes + 1.6 1.5.2 2000 CNRI no + 2.0 1.6 2000 BeOpen.com no + 1.6.1 1.6 2001 CNRI yes (2) + 2.1 2.0+1.6.1 2001 PSF no + 2.0.1 2.0+1.6.1 2001 PSF yes + 2.1.1 2.1+2.0.1 2001 PSF yes + 2.1.2 2.1.1 2002 PSF yes + 2.1.3 2.1.2 2002 PSF yes + 2.2 and above 2.1.1 2001-now PSF yes + +Footnotes: + +(1) GPL-compatible doesn't mean that we're distributing Python under + the GPL. All Python licenses, unlike the GPL, let you distribute + a modified version without making your changes open source. The + GPL-compatible licenses make it possible to combine Python with + other software that is released under the GPL; the others don't. + +(2) According to Richard Stallman, 1.6.1 is not GPL-compatible, + because its license has a choice of law clause. According to + CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1 + is "not incompatible" with the GPL. + +Thanks to the many outside volunteers who have worked under Guido's +direction to make these releases possible. + + +B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON +=============================================================== + +Python software and documentation are licensed under the +Python Software Foundation License Version 2. + +Starting with Python 3.8.6, examples, recipes, and other code in +the documentation are dual licensed under the PSF License Version 2 +and the Zero-Clause BSD license. + +Some software incorporated into Python is under different licenses. +The licenses are listed with code falling under that license. + + +PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 +-------------------------------------------- + +1. This LICENSE AGREEMENT is between the Python Software Foundation +("PSF"), and the Individual or Organization ("Licensee") accessing and +otherwise using this software ("Python") in source or binary form and +its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, PSF hereby +grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, +analyze, test, perform and/or display publicly, prepare derivative works, +distribute, and otherwise use Python alone or in any derivative version, +provided, however, that PSF's License Agreement and PSF's notice of copyright, +i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, +2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation; +All Rights Reserved" are retained in Python alone or in any derivative version +prepared by Licensee. + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python. + +4. PSF is making Python available to Licensee on an "AS IS" +basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. Nothing in this License Agreement shall be deemed to create any +relationship of agency, partnership, or joint venture between PSF and +Licensee. This License Agreement does not grant permission to use PSF +trademarks or trade name in a trademark sense to endorse or promote +products or services of Licensee, or any third party. + +8. By copying, installing or otherwise using Python, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 +------------------------------------------- + +BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1 + +1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an +office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the +Individual or Organization ("Licensee") accessing and otherwise using +this software in source or binary form and its associated +documentation ("the Software"). + +2. Subject to the terms and conditions of this BeOpen Python License +Agreement, BeOpen hereby grants Licensee a non-exclusive, +royalty-free, world-wide license to reproduce, analyze, test, perform +and/or display publicly, prepare derivative works, distribute, and +otherwise use the Software alone or in any derivative version, +provided, however, that the BeOpen Python License is retained in the +Software, alone or in any derivative version prepared by Licensee. + +3. BeOpen is making the Software available to Licensee on an "AS IS" +basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE +SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS +AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY +DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +5. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +6. This License Agreement shall be governed by and interpreted in all +respects by the law of the State of California, excluding conflict of +law provisions. Nothing in this License Agreement shall be deemed to +create any relationship of agency, partnership, or joint venture +between BeOpen and Licensee. This License Agreement does not grant +permission to use BeOpen trademarks or trade names in a trademark +sense to endorse or promote products or services of Licensee, or any +third party. As an exception, the "BeOpen Python" logos available at +http://www.pythonlabs.com/logos.html may be used according to the +permissions granted on that web page. + +7. By copying, installing or otherwise using the software, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1 +--------------------------------------- + +1. This LICENSE AGREEMENT is between the Corporation for National +Research Initiatives, having an office at 1895 Preston White Drive, +Reston, VA 20191 ("CNRI"), and the Individual or Organization +("Licensee") accessing and otherwise using Python 1.6.1 software in +source or binary form and its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, CNRI +hereby grants Licensee a nonexclusive, royalty-free, world-wide +license to reproduce, analyze, test, perform and/or display publicly, +prepare derivative works, distribute, and otherwise use Python 1.6.1 +alone or in any derivative version, provided, however, that CNRI's +License Agreement and CNRI's notice of copyright, i.e., "Copyright (c) +1995-2001 Corporation for National Research Initiatives; All Rights +Reserved" are retained in Python 1.6.1 alone or in any derivative +version prepared by Licensee. Alternately, in lieu of CNRI's License +Agreement, Licensee may substitute the following text (omitting the +quotes): "Python 1.6.1 is made available subject to the terms and +conditions in CNRI's License Agreement. This Agreement together with +Python 1.6.1 may be located on the Internet using the following +unique, persistent identifier (known as a handle): 1895.22/1013. This +Agreement may also be obtained from a proxy server on the Internet +using the following URL: http://hdl.handle.net/1895.22/1013". + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python 1.6.1 or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python 1.6.1. + +4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" +basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. This License Agreement shall be governed by the federal +intellectual property law of the United States, including without +limitation the federal copyright law, and, to the extent such +U.S. federal law does not apply, by the law of the Commonwealth of +Virginia, excluding Virginia's conflict of law provisions. +Notwithstanding the foregoing, with regard to derivative works based +on Python 1.6.1 that incorporate non-separable material that was +previously distributed under the GNU General Public License (GPL), the +law of the Commonwealth of Virginia shall govern this License +Agreement only as to issues arising under or with respect to +Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this +License Agreement shall be deemed to create any relationship of +agency, partnership, or joint venture between CNRI and Licensee. This +License Agreement does not grant permission to use CNRI trademarks or +trade name in a trademark sense to endorse or promote products or +services of Licensee, or any third party. + +8. By clicking on the "ACCEPT" button where indicated, or by copying, +installing or otherwise using Python 1.6.1, Licensee agrees to be +bound by the terms and conditions of this License Agreement. + + ACCEPT + + +CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 +-------------------------------------------------- + +Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, +The Netherlands. All rights reserved. + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior +permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION +---------------------------------------------------------------------- + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. diff --git a/marketing/Scripts/2to3-script.py b/marketing/Scripts/2to3-script.py new file mode 100644 index 0000000000000000000000000000000000000000..a1a85961be0ab3061e672af7f5d309e2b73e60e0 --- /dev/null +++ b/marketing/Scripts/2to3-script.py @@ -0,0 +1,4 @@ +import sys +from lib2to3.main import main + +sys.exit(main("lib2to3.fixes")) diff --git a/marketing/Scripts/2to3.exe b/marketing/Scripts/2to3.exe new file mode 100644 index 0000000000000000000000000000000000000000..0251e7a4bca1830f4777cb4f855f3e5fd3b2046a Binary files /dev/null and b/marketing/Scripts/2to3.exe differ diff --git a/marketing/Scripts/idle-script.py b/marketing/Scripts/idle-script.py new file mode 100644 index 0000000000000000000000000000000000000000..c1bda72fc516909184a53e2d1fe25b5399595f26 --- /dev/null +++ b/marketing/Scripts/idle-script.py @@ -0,0 +1,4 @@ + +from idlelib.pyshell import main +if __name__ == '__main__': + main() diff --git a/marketing/Scripts/idle.exe b/marketing/Scripts/idle.exe new file mode 100644 index 0000000000000000000000000000000000000000..0251e7a4bca1830f4777cb4f855f3e5fd3b2046a Binary files /dev/null and b/marketing/Scripts/idle.exe differ diff --git a/marketing/Scripts/pip-script.py b/marketing/Scripts/pip-script.py new file mode 100644 index 0000000000000000000000000000000000000000..97142b1170eb23dfd274bd9e6627c1a70542e9ca --- /dev/null +++ b/marketing/Scripts/pip-script.py @@ -0,0 +1,10 @@ + +# -*- coding: utf-8 -*- +import re +import sys + +from pip._internal.cli.main import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/marketing/Scripts/pip.exe b/marketing/Scripts/pip.exe new file mode 100644 index 0000000000000000000000000000000000000000..0251e7a4bca1830f4777cb4f855f3e5fd3b2046a Binary files /dev/null and b/marketing/Scripts/pip.exe differ diff --git a/marketing/Scripts/pip3-script.py b/marketing/Scripts/pip3-script.py new file mode 100644 index 0000000000000000000000000000000000000000..97142b1170eb23dfd274bd9e6627c1a70542e9ca --- /dev/null +++ b/marketing/Scripts/pip3-script.py @@ -0,0 +1,10 @@ + +# -*- coding: utf-8 -*- +import re +import sys + +from pip._internal.cli.main import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/marketing/Scripts/pip3.exe b/marketing/Scripts/pip3.exe new file mode 100644 index 0000000000000000000000000000000000000000..0251e7a4bca1830f4777cb4f855f3e5fd3b2046a Binary files /dev/null and b/marketing/Scripts/pip3.exe differ diff --git a/marketing/Scripts/pydoc-script.py b/marketing/Scripts/pydoc-script.py new file mode 100644 index 0000000000000000000000000000000000000000..311646a5197da03d70f48bc0769f45272b195a12 --- /dev/null +++ b/marketing/Scripts/pydoc-script.py @@ -0,0 +1,4 @@ + +import pydoc +if __name__ == '__main__': + pydoc.cli() diff --git a/marketing/Scripts/pydoc.exe b/marketing/Scripts/pydoc.exe new file mode 100644 index 0000000000000000000000000000000000000000..0251e7a4bca1830f4777cb4f855f3e5fd3b2046a Binary files /dev/null and b/marketing/Scripts/pydoc.exe differ diff --git a/marketing/Scripts/wheel-script.py b/marketing/Scripts/wheel-script.py new file mode 100644 index 0000000000000000000000000000000000000000..944d4bb3f0725a802c2d72b539a07d1305fe031d --- /dev/null +++ b/marketing/Scripts/wheel-script.py @@ -0,0 +1,10 @@ + +# -*- coding: utf-8 -*- +import re +import sys + +from wheel.cli import main + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/marketing/Scripts/wheel.exe b/marketing/Scripts/wheel.exe new file mode 100644 index 0000000000000000000000000000000000000000..0251e7a4bca1830f4777cb4f855f3e5fd3b2046a Binary files /dev/null and b/marketing/Scripts/wheel.exe differ diff --git a/marketing/Tools/demo/__pycache__/beer.cpython-39.pyc b/marketing/Tools/demo/__pycache__/beer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f86c8f1b09080bd9b7cd95946c048fee40177e0e Binary files /dev/null and b/marketing/Tools/demo/__pycache__/beer.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/eiffel.cpython-39.pyc b/marketing/Tools/demo/__pycache__/eiffel.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f409cdb74a7d38ba2346a2d98df3077778a610c Binary files /dev/null and b/marketing/Tools/demo/__pycache__/eiffel.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/hanoi.cpython-39.pyc b/marketing/Tools/demo/__pycache__/hanoi.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9329cc135587431a0f1d14131d58df2c7ce035fa Binary files /dev/null and b/marketing/Tools/demo/__pycache__/hanoi.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/life.cpython-39.pyc b/marketing/Tools/demo/__pycache__/life.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a56bb7d94b5be3e6bd070f15140bd01b2243f01c Binary files /dev/null and b/marketing/Tools/demo/__pycache__/life.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/markov.cpython-39.pyc b/marketing/Tools/demo/__pycache__/markov.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc9a228380a893905ad2f389942d32d30504817d Binary files /dev/null and b/marketing/Tools/demo/__pycache__/markov.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/mcast.cpython-39.pyc b/marketing/Tools/demo/__pycache__/mcast.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0173e438dd833a45678947dce9dbb75142dd6a65 Binary files /dev/null and b/marketing/Tools/demo/__pycache__/mcast.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/queens.cpython-39.pyc b/marketing/Tools/demo/__pycache__/queens.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..997ce050e588614147c01e4f79dee6523f5fd5c6 Binary files /dev/null and b/marketing/Tools/demo/__pycache__/queens.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/redemo.cpython-39.pyc b/marketing/Tools/demo/__pycache__/redemo.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9383299343a968538367be980a29071573c7dafd Binary files /dev/null and b/marketing/Tools/demo/__pycache__/redemo.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/rpython.cpython-39.pyc b/marketing/Tools/demo/__pycache__/rpython.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b2669f061105a352178bcb308ea61d6bce8c13d Binary files /dev/null and b/marketing/Tools/demo/__pycache__/rpython.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/rpythond.cpython-39.pyc b/marketing/Tools/demo/__pycache__/rpythond.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e44335f2cf3f99f0b4ca4c9bcead16e66341f1a2 Binary files /dev/null and b/marketing/Tools/demo/__pycache__/rpythond.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/sortvisu.cpython-39.pyc b/marketing/Tools/demo/__pycache__/sortvisu.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae0c85b5ba1b8dda3252fd85602b232875275e5e Binary files /dev/null and b/marketing/Tools/demo/__pycache__/sortvisu.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/spreadsheet.cpython-39.pyc b/marketing/Tools/demo/__pycache__/spreadsheet.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d65270e18c348db670b863ae8e9a7157112aea7d Binary files /dev/null and b/marketing/Tools/demo/__pycache__/spreadsheet.cpython-39.pyc differ diff --git a/marketing/Tools/demo/__pycache__/vector.cpython-39.pyc b/marketing/Tools/demo/__pycache__/vector.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8626efcd4843f61404a242b6ff3471c389859480 Binary files /dev/null and b/marketing/Tools/demo/__pycache__/vector.cpython-39.pyc differ diff --git a/marketing/Tools/demo/beer.py b/marketing/Tools/demo/beer.py new file mode 100644 index 0000000000000000000000000000000000000000..af58380e0f5a1ae8dd852814f2c877f59b12de7e --- /dev/null +++ b/marketing/Tools/demo/beer.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 + +""" +A Python version of the classic "bottles of beer on the wall" programming +example. + +By Guido van Rossum, demystified after a version by Fredrik Lundh. +""" + +import sys + +n = 100 +if sys.argv[1:]: + n = int(sys.argv[1]) + +def bottle(n): + if n == 0: return "no more bottles of beer" + if n == 1: return "one bottle of beer" + return str(n) + " bottles of beer" + +for i in range(n, 0, -1): + print(bottle(i), "on the wall,") + print(bottle(i) + ".") + print("Take one down, pass it around,") + print(bottle(i-1), "on the wall.") diff --git a/marketing/Tools/demo/eiffel.py b/marketing/Tools/demo/eiffel.py new file mode 100644 index 0000000000000000000000000000000000000000..a76c2324dd6a671d615c1d9bf6238b89e4c150ce --- /dev/null +++ b/marketing/Tools/demo/eiffel.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python3 + +""" +Support Eiffel-style preconditions and postconditions for functions. + +An example for Python metaclasses. +""" + +import unittest +from types import FunctionType as function + +class EiffelBaseMetaClass(type): + + def __new__(meta, name, bases, dict): + meta.convert_methods(dict) + return super(EiffelBaseMetaClass, meta).__new__( + meta, name, bases, dict) + + @classmethod + def convert_methods(cls, dict): + """Replace functions in dict with EiffelMethod wrappers. + + The dict is modified in place. + + If a method ends in _pre or _post, it is removed from the dict + regardless of whether there is a corresponding method. + """ + # find methods with pre or post conditions + methods = [] + for k, v in dict.items(): + if k.endswith('_pre') or k.endswith('_post'): + assert isinstance(v, function) + elif isinstance(v, function): + methods.append(k) + for m in methods: + pre = dict.get("%s_pre" % m) + post = dict.get("%s_post" % m) + if pre or post: + dict[m] = cls.make_eiffel_method(dict[m], pre, post) + + +class EiffelMetaClass1(EiffelBaseMetaClass): + # an implementation of the "eiffel" meta class that uses nested functions + + @staticmethod + def make_eiffel_method(func, pre, post): + def method(self, *args, **kwargs): + if pre: + pre(self, *args, **kwargs) + rv = func(self, *args, **kwargs) + if post: + post(self, rv, *args, **kwargs) + return rv + + if func.__doc__: + method.__doc__ = func.__doc__ + + return method + + +class EiffelMethodWrapper: + + def __init__(self, inst, descr): + self._inst = inst + self._descr = descr + + def __call__(self, *args, **kwargs): + return self._descr.callmethod(self._inst, args, kwargs) + + +class EiffelDescriptor: + + def __init__(self, func, pre, post): + self._func = func + self._pre = pre + self._post = post + + self.__name__ = func.__name__ + self.__doc__ = func.__doc__ + + def __get__(self, obj, cls=None): + return EiffelMethodWrapper(obj, self) + + def callmethod(self, inst, args, kwargs): + if self._pre: + self._pre(inst, *args, **kwargs) + x = self._func(inst, *args, **kwargs) + if self._post: + self._post(inst, x, *args, **kwargs) + return x + + +class EiffelMetaClass2(EiffelBaseMetaClass): + # an implementation of the "eiffel" meta class that uses descriptors + + make_eiffel_method = EiffelDescriptor + + +class Tests(unittest.TestCase): + + def testEiffelMetaClass1(self): + self._test(EiffelMetaClass1) + + def testEiffelMetaClass2(self): + self._test(EiffelMetaClass2) + + def _test(self, metaclass): + class Eiffel(metaclass=metaclass): + pass + + class Test(Eiffel): + def m(self, arg): + """Make it a little larger""" + return arg + 1 + + def m2(self, arg): + """Make it a little larger""" + return arg + 1 + + def m2_pre(self, arg): + assert arg > 0 + + def m2_post(self, result, arg): + assert result > arg + + class Sub(Test): + def m2(self, arg): + return arg**2 + + def m2_post(self, Result, arg): + super(Sub, self).m2_post(Result, arg) + assert Result < 100 + + t = Test() + self.assertEqual(t.m(1), 2) + self.assertEqual(t.m2(1), 2) + self.assertRaises(AssertionError, t.m2, 0) + + s = Sub() + self.assertRaises(AssertionError, s.m2, 1) + self.assertRaises(AssertionError, s.m2, 10) + self.assertEqual(s.m2(5), 25) + + +if __name__ == "__main__": + unittest.main() diff --git a/marketing/Tools/demo/hanoi.py b/marketing/Tools/demo/hanoi.py new file mode 100644 index 0000000000000000000000000000000000000000..8db895c244581048fb18df21362e0740c894497f --- /dev/null +++ b/marketing/Tools/demo/hanoi.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python3 + +""" +Animated Towers of Hanoi using Tk with optional bitmap file in background. + +Usage: hanoi.py [n [bitmapfile]] + +n is the number of pieces to animate; default is 4, maximum 15. + +The bitmap file can be any X11 bitmap file (look in /usr/include/X11/bitmaps for +samples); it is displayed as the background of the animation. Default is no +bitmap. +""" + +from tkinter import Tk, Canvas + +# Basic Towers-of-Hanoi algorithm: move n pieces from a to b, using c +# as temporary. For each move, call report() +def hanoi(n, a, b, c, report): + if n <= 0: return + hanoi(n-1, a, c, b, report) + report(n, a, b) + hanoi(n-1, c, b, a, report) + + +# The graphical interface +class Tkhanoi: + + # Create our objects + def __init__(self, n, bitmap=None): + self.n = n + self.tk = tk = Tk() + self.canvas = c = Canvas(tk) + c.pack() + width, height = tk.getint(c['width']), tk.getint(c['height']) + + # Add background bitmap + if bitmap: + self.bitmap = c.create_bitmap(width//2, height//2, + bitmap=bitmap, + foreground='blue') + + # Generate pegs + pegwidth = 10 + pegheight = height//2 + pegdist = width//3 + x1, y1 = (pegdist-pegwidth)//2, height*1//3 + x2, y2 = x1+pegwidth, y1+pegheight + self.pegs = [] + p = c.create_rectangle(x1, y1, x2, y2, fill='black') + self.pegs.append(p) + x1, x2 = x1+pegdist, x2+pegdist + p = c.create_rectangle(x1, y1, x2, y2, fill='black') + self.pegs.append(p) + x1, x2 = x1+pegdist, x2+pegdist + p = c.create_rectangle(x1, y1, x2, y2, fill='black') + self.pegs.append(p) + self.tk.update() + + # Generate pieces + pieceheight = pegheight//16 + maxpiecewidth = pegdist*2//3 + minpiecewidth = 2*pegwidth + self.pegstate = [[], [], []] + self.pieces = {} + x1, y1 = (pegdist-maxpiecewidth)//2, y2-pieceheight-2 + x2, y2 = x1+maxpiecewidth, y1+pieceheight + dx = (maxpiecewidth-minpiecewidth) // (2*max(1, n-1)) + for i in range(n, 0, -1): + p = c.create_rectangle(x1, y1, x2, y2, fill='red') + self.pieces[i] = p + self.pegstate[0].append(i) + x1, x2 = x1 + dx, x2-dx + y1, y2 = y1 - pieceheight-2, y2-pieceheight-2 + self.tk.update() + self.tk.after(25) + + # Run -- never returns + def run(self): + while True: + hanoi(self.n, 0, 1, 2, self.report) + hanoi(self.n, 1, 2, 0, self.report) + hanoi(self.n, 2, 0, 1, self.report) + hanoi(self.n, 0, 2, 1, self.report) + hanoi(self.n, 2, 1, 0, self.report) + hanoi(self.n, 1, 0, 2, self.report) + + # Reporting callback for the actual hanoi function + def report(self, i, a, b): + if self.pegstate[a][-1] != i: raise RuntimeError # Assertion + del self.pegstate[a][-1] + p = self.pieces[i] + c = self.canvas + + # Lift the piece above peg a + ax1, ay1, ax2, ay2 = c.bbox(self.pegs[a]) + while True: + x1, y1, x2, y2 = c.bbox(p) + if y2 < ay1: break + c.move(p, 0, -1) + self.tk.update() + + # Move it towards peg b + bx1, by1, bx2, by2 = c.bbox(self.pegs[b]) + newcenter = (bx1+bx2)//2 + while True: + x1, y1, x2, y2 = c.bbox(p) + center = (x1+x2)//2 + if center == newcenter: break + if center > newcenter: c.move(p, -1, 0) + else: c.move(p, 1, 0) + self.tk.update() + + # Move it down on top of the previous piece + pieceheight = y2-y1 + newbottom = by2 - pieceheight*len(self.pegstate[b]) - 2 + while True: + x1, y1, x2, y2 = c.bbox(p) + if y2 >= newbottom: break + c.move(p, 0, 1) + self.tk.update() + + # Update peg state + self.pegstate[b].append(i) + + +def main(): + import sys + + # First argument is number of pegs, default 4 + if sys.argv[1:]: + n = int(sys.argv[1]) + else: + n = 4 + + # Second argument is bitmap file, default none + if sys.argv[2:]: + bitmap = sys.argv[2] + # Reverse meaning of leading '@' compared to Tk + if bitmap[0] == '@': bitmap = bitmap[1:] + else: bitmap = '@' + bitmap + else: + bitmap = None + + # Create the graphical objects... + h = Tkhanoi(n, bitmap) + + # ...and run! + h.run() + + +# Call main when run as script +if __name__ == '__main__': + main() diff --git a/marketing/Tools/demo/life.py b/marketing/Tools/demo/life.py new file mode 100644 index 0000000000000000000000000000000000000000..fc4cb4952dce69d658821e2aa059d97436976003 --- /dev/null +++ b/marketing/Tools/demo/life.py @@ -0,0 +1,262 @@ +#!/usr/bin/env python3 + +""" +A curses-based version of Conway's Game of Life. + +An empty board will be displayed, and the following commands are available: + E : Erase the board + R : Fill the board randomly + S : Step for a single generation + C : Update continuously until a key is struck + Q : Quit + Cursor keys : Move the cursor around the board + Space or Enter : Toggle the contents of the cursor's position + +Contributed by Andrew Kuchling, Mouse support and color by Dafydd Crosby. +""" + +import curses +import random + + +class LifeBoard: + """Encapsulates a Life board + + Attributes: + X,Y : horizontal and vertical size of the board + state : dictionary mapping (x,y) to 0 or 1 + + Methods: + display(update_board) -- If update_board is true, compute the + next generation. Then display the state + of the board and refresh the screen. + erase() -- clear the entire board + make_random() -- fill the board randomly + set(y,x) -- set the given cell to Live; doesn't refresh the screen + toggle(y,x) -- change the given cell from live to dead, or vice + versa, and refresh the screen display + + """ + def __init__(self, scr, char=ord('*')): + """Create a new LifeBoard instance. + + scr -- curses screen object to use for display + char -- character used to render live cells (default: '*') + """ + self.state = {} + self.scr = scr + Y, X = self.scr.getmaxyx() + self.X, self.Y = X - 2, Y - 2 - 1 + self.char = char + self.scr.clear() + + # Draw a border around the board + border_line = '+' + (self.X * '-') + '+' + self.scr.addstr(0, 0, border_line) + self.scr.addstr(self.Y + 1, 0, border_line) + for y in range(0, self.Y): + self.scr.addstr(1 + y, 0, '|') + self.scr.addstr(1 + y, self.X + 1, '|') + self.scr.refresh() + + def set(self, y, x): + """Set a cell to the live state""" + if x < 0 or self.X <= x or y < 0 or self.Y <= y: + raise ValueError("Coordinates out of range %i,%i" % (y, x)) + self.state[x, y] = 1 + + def toggle(self, y, x): + """Toggle a cell's state between live and dead""" + if x < 0 or self.X <= x or y < 0 or self.Y <= y: + raise ValueError("Coordinates out of range %i,%i" % (y, x)) + if (x, y) in self.state: + del self.state[x, y] + self.scr.addch(y + 1, x + 1, ' ') + else: + self.state[x, y] = 1 + if curses.has_colors(): + # Let's pick a random color! + self.scr.attrset(curses.color_pair(random.randrange(1, 7))) + self.scr.addch(y + 1, x + 1, self.char) + self.scr.attrset(0) + self.scr.refresh() + + def erase(self): + """Clear the entire board and update the board display""" + self.state = {} + self.display(update_board=False) + + def display(self, update_board=True): + """Display the whole board, optionally computing one generation""" + M, N = self.X, self.Y + if not update_board: + for i in range(0, M): + for j in range(0, N): + if (i, j) in self.state: + self.scr.addch(j + 1, i + 1, self.char) + else: + self.scr.addch(j + 1, i + 1, ' ') + self.scr.refresh() + return + + d = {} + self.boring = 1 + for i in range(0, M): + L = range(max(0, i - 1), min(M, i + 2)) + for j in range(0, N): + s = 0 + live = (i, j) in self.state + for k in range(max(0, j - 1), min(N, j + 2)): + for l in L: + if (l, k) in self.state: + s += 1 + s -= live + if s == 3: + # Birth + d[i, j] = 1 + if curses.has_colors(): + # Let's pick a random color! + self.scr.attrset(curses.color_pair( + random.randrange(1, 7))) + self.scr.addch(j + 1, i + 1, self.char) + self.scr.attrset(0) + if not live: + self.boring = 0 + elif s == 2 and live: + # Survival + d[i, j] = 1 + elif live: + # Death + self.scr.addch(j + 1, i + 1, ' ') + self.boring = 0 + self.state = d + self.scr.refresh() + + def make_random(self): + "Fill the board with a random pattern" + self.state = {} + for i in range(0, self.X): + for j in range(0, self.Y): + if random.random() > 0.5: + self.set(j, i) + + +def erase_menu(stdscr, menu_y): + "Clear the space where the menu resides" + stdscr.move(menu_y, 0) + stdscr.clrtoeol() + stdscr.move(menu_y + 1, 0) + stdscr.clrtoeol() + + +def display_menu(stdscr, menu_y): + "Display the menu of possible keystroke commands" + erase_menu(stdscr, menu_y) + + # If color, then light the menu up :-) + if curses.has_colors(): + stdscr.attrset(curses.color_pair(1)) + stdscr.addstr(menu_y, 4, + 'Use the cursor keys to move, and space or Enter to toggle a cell.') + stdscr.addstr(menu_y + 1, 4, + 'E)rase the board, R)andom fill, S)tep once or C)ontinuously, Q)uit') + stdscr.attrset(0) + + +def keyloop(stdscr): + # Clear the screen and display the menu of keys + stdscr.clear() + stdscr_y, stdscr_x = stdscr.getmaxyx() + menu_y = (stdscr_y - 3) - 1 + display_menu(stdscr, menu_y) + + # If color, then initialize the color pairs + if curses.has_colors(): + curses.init_pair(1, curses.COLOR_BLUE, 0) + curses.init_pair(2, curses.COLOR_CYAN, 0) + curses.init_pair(3, curses.COLOR_GREEN, 0) + curses.init_pair(4, curses.COLOR_MAGENTA, 0) + curses.init_pair(5, curses.COLOR_RED, 0) + curses.init_pair(6, curses.COLOR_YELLOW, 0) + curses.init_pair(7, curses.COLOR_WHITE, 0) + + # Set up the mask to listen for mouse events + curses.mousemask(curses.BUTTON1_CLICKED) + + # Allocate a subwindow for the Life board and create the board object + subwin = stdscr.subwin(stdscr_y - 3, stdscr_x, 0, 0) + board = LifeBoard(subwin, char=ord('*')) + board.display(update_board=False) + + # xpos, ypos are the cursor's position + xpos, ypos = board.X // 2, board.Y // 2 + + # Main loop: + while True: + stdscr.move(1 + ypos, 1 + xpos) # Move the cursor + c = stdscr.getch() # Get a keystroke + if 0 < c < 256: + c = chr(c) + if c in ' \n': + board.toggle(ypos, xpos) + elif c in 'Cc': + erase_menu(stdscr, menu_y) + stdscr.addstr(menu_y, 6, ' Hit any key to stop continuously ' + 'updating the screen.') + stdscr.refresh() + # Activate nodelay mode; getch() will return -1 + # if no keystroke is available, instead of waiting. + stdscr.nodelay(1) + while True: + c = stdscr.getch() + if c != -1: + break + stdscr.addstr(0, 0, '/') + stdscr.refresh() + board.display() + stdscr.addstr(0, 0, '+') + stdscr.refresh() + + stdscr.nodelay(0) # Disable nodelay mode + display_menu(stdscr, menu_y) + + elif c in 'Ee': + board.erase() + elif c in 'Qq': + break + elif c in 'Rr': + board.make_random() + board.display(update_board=False) + elif c in 'Ss': + board.display() + else: + # Ignore incorrect keys + pass + elif c == curses.KEY_UP and ypos > 0: + ypos -= 1 + elif c == curses.KEY_DOWN and ypos + 1 < board.Y: + ypos += 1 + elif c == curses.KEY_LEFT and xpos > 0: + xpos -= 1 + elif c == curses.KEY_RIGHT and xpos + 1 < board.X: + xpos += 1 + elif c == curses.KEY_MOUSE: + mouse_id, mouse_x, mouse_y, mouse_z, button_state = curses.getmouse() + if (mouse_x > 0 and mouse_x < board.X + 1 and + mouse_y > 0 and mouse_y < board.Y + 1): + xpos = mouse_x - 1 + ypos = mouse_y - 1 + board.toggle(ypos, xpos) + else: + # They've clicked outside the board + curses.flash() + else: + # Ignore incorrect keys + pass + + +def main(stdscr): + keyloop(stdscr) # Enter the main loop + +if __name__ == '__main__': + curses.wrapper(main) diff --git a/marketing/Tools/demo/markov.py b/marketing/Tools/demo/markov.py new file mode 100644 index 0000000000000000000000000000000000000000..9729f3820fa026f272e569d0d0e3c40904db79a7 --- /dev/null +++ b/marketing/Tools/demo/markov.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 + +""" +Markov chain simulation of words or characters. +""" + +class Markov: + def __init__(self, histsize, choice): + self.histsize = histsize + self.choice = choice + self.trans = {} + + def add(self, state, next): + self.trans.setdefault(state, []).append(next) + + def put(self, seq): + n = self.histsize + add = self.add + add(None, seq[:0]) + for i in range(len(seq)): + add(seq[max(0, i-n):i], seq[i:i+1]) + add(seq[len(seq)-n:], None) + + def get(self): + choice = self.choice + trans = self.trans + n = self.histsize + seq = choice(trans[None]) + while True: + subseq = seq[max(0, len(seq)-n):] + options = trans[subseq] + next = choice(options) + if not next: + break + seq += next + return seq + + +def test(): + import sys, random, getopt + args = sys.argv[1:] + try: + opts, args = getopt.getopt(args, '0123456789cdwq') + except getopt.error: + print('Usage: %s [-#] [-cddqw] [file] ...' % sys.argv[0]) + print('Options:') + print('-#: 1-digit history size (default 2)') + print('-c: characters (default)') + print('-w: words') + print('-d: more debugging output') + print('-q: no debugging output') + print('Input files (default stdin) are split in paragraphs') + print('separated blank lines and each paragraph is split') + print('in words by whitespace, then reconcatenated with') + print('exactly one space separating words.') + print('Output consists of paragraphs separated by blank') + print('lines, where lines are no longer than 72 characters.') + sys.exit(2) + histsize = 2 + do_words = False + debug = 1 + for o, a in opts: + if '-0' <= o <= '-9': histsize = int(o[1:]) + if o == '-c': do_words = False + if o == '-d': debug += 1 + if o == '-q': debug = 0 + if o == '-w': do_words = True + if not args: + args = ['-'] + + m = Markov(histsize, random.choice) + try: + for filename in args: + if filename == '-': + f = sys.stdin + if f.isatty(): + print('Sorry, need stdin from file') + continue + else: + f = open(filename, 'r') + with f: + if debug: print('processing', filename, '...') + text = f.read() + paralist = text.split('\n\n') + for para in paralist: + if debug > 1: print('feeding ...') + words = para.split() + if words: + if do_words: + data = tuple(words) + else: + data = ' '.join(words) + m.put(data) + except KeyboardInterrupt: + print('Interrupted -- continue with data read so far') + if not m.trans: + print('No valid input files') + return + if debug: print('done.') + + if debug > 1: + for key in m.trans.keys(): + if key is None or len(key) < histsize: + print(repr(key), m.trans[key]) + if histsize == 0: print(repr(''), m.trans['']) + print() + while True: + data = m.get() + if do_words: + words = data + else: + words = data.split() + n = 0 + limit = 72 + for w in words: + if n + len(w) > limit: + print() + n = 0 + print(w, end=' ') + n += len(w) + 1 + print() + print() + +if __name__ == "__main__": + test() diff --git a/marketing/Tools/demo/mcast.py b/marketing/Tools/demo/mcast.py new file mode 100644 index 0000000000000000000000000000000000000000..924c7c3e80e7d28ea084cf393e3cc0d469d79593 --- /dev/null +++ b/marketing/Tools/demo/mcast.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python3 + +""" +Send/receive UDP multicast packets. +Requires that your OS kernel supports IP multicast. + +Usage: + mcast -s (sender, IPv4) + mcast -s -6 (sender, IPv6) + mcast (receivers, IPv4) + mcast -6 (receivers, IPv6) +""" + +MYPORT = 8123 +MYGROUP_4 = '225.0.0.250' +MYGROUP_6 = 'ff15:7079:7468:6f6e:6465:6d6f:6d63:6173' +MYTTL = 1 # Increase to reach other networks + +import time +import struct +import socket +import sys + +def main(): + group = MYGROUP_6 if "-6" in sys.argv[1:] else MYGROUP_4 + + if "-s" in sys.argv[1:]: + sender(group) + else: + receiver(group) + + +def sender(group): + addrinfo = socket.getaddrinfo(group, None)[0] + + s = socket.socket(addrinfo[0], socket.SOCK_DGRAM) + + # Set Time-to-live (optional) + ttl_bin = struct.pack('@i', MYTTL) + if addrinfo[0] == socket.AF_INET: # IPv4 + s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, ttl_bin) + else: + s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_HOPS, ttl_bin) + + while True: + data = repr(time.time()).encode('utf-8') + b'\0' + s.sendto(data, (addrinfo[4][0], MYPORT)) + time.sleep(1) + + +def receiver(group): + # Look up multicast group address in name server and find out IP version + addrinfo = socket.getaddrinfo(group, None)[0] + + # Create a socket + s = socket.socket(addrinfo[0], socket.SOCK_DGRAM) + + # Allow multiple copies of this program on one machine + # (not strictly needed) + s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + + # Bind it to the port + s.bind(('', MYPORT)) + + group_bin = socket.inet_pton(addrinfo[0], addrinfo[4][0]) + # Join group + if addrinfo[0] == socket.AF_INET: # IPv4 + mreq = group_bin + struct.pack('=I', socket.INADDR_ANY) + s.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq) + else: + mreq = group_bin + struct.pack('@I', 0) + s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP, mreq) + + # Loop, printing any data we receive + while True: + data, sender = s.recvfrom(1500) + while data[-1:] == '\0': data = data[:-1] # Strip trailing \0's + print(str(sender) + ' ' + repr(data)) + + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/demo/queens.py b/marketing/Tools/demo/queens.py new file mode 100644 index 0000000000000000000000000000000000000000..dcc1bae1ab332bcfe3250c64dff12e9fd002e483 --- /dev/null +++ b/marketing/Tools/demo/queens.py @@ -0,0 +1,85 @@ +#!/usr/bin/env python3 + +""" +N queens problem. + +The (well-known) problem is due to Niklaus Wirth. + +This solution is inspired by Dijkstra (Structured Programming). It is +a classic recursive backtracking approach. +""" + +N = 8 # Default; command line overrides + +class Queens: + + def __init__(self, n=N): + self.n = n + self.reset() + + def reset(self): + n = self.n + self.y = [None] * n # Where is the queen in column x + self.row = [0] * n # Is row[y] safe? + self.up = [0] * (2*n-1) # Is upward diagonal[x-y] safe? + self.down = [0] * (2*n-1) # Is downward diagonal[x+y] safe? + self.nfound = 0 # Instrumentation + + def solve(self, x=0): # Recursive solver + for y in range(self.n): + if self.safe(x, y): + self.place(x, y) + if x+1 == self.n: + self.display() + else: + self.solve(x+1) + self.remove(x, y) + + def safe(self, x, y): + return not self.row[y] and not self.up[x-y] and not self.down[x+y] + + def place(self, x, y): + self.y[x] = y + self.row[y] = 1 + self.up[x-y] = 1 + self.down[x+y] = 1 + + def remove(self, x, y): + self.y[x] = None + self.row[y] = 0 + self.up[x-y] = 0 + self.down[x+y] = 0 + + silent = 0 # If true, count solutions only + + def display(self): + self.nfound = self.nfound + 1 + if self.silent: + return + print('+-' + '--'*self.n + '+') + for y in range(self.n-1, -1, -1): + print('|', end=' ') + for x in range(self.n): + if self.y[x] == y: + print("Q", end=' ') + else: + print(".", end=' ') + print('|') + print('+-' + '--'*self.n + '+') + +def main(): + import sys + silent = 0 + n = N + if sys.argv[1:2] == ['-n']: + silent = 1 + del sys.argv[1] + if sys.argv[1:]: + n = int(sys.argv[1]) + q = Queens(n) + q.silent = silent + q.solve() + print("Found", q.nfound, "solutions.") + +if __name__ == "__main__": + main() diff --git a/marketing/Tools/demo/redemo.py b/marketing/Tools/demo/redemo.py new file mode 100644 index 0000000000000000000000000000000000000000..f801dfce5fe1a3dc8baf3242d18bf20c424efe21 --- /dev/null +++ b/marketing/Tools/demo/redemo.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 + +"""Basic regular expression demonstration facility (Perl style syntax).""" + +from tkinter import * +import re + +class ReDemo: + + def __init__(self, master): + self.master = master + + self.promptdisplay = Label(self.master, anchor=W, + text="Enter a Perl-style regular expression:") + self.promptdisplay.pack(side=TOP, fill=X) + + self.regexdisplay = Entry(self.master) + self.regexdisplay.pack(fill=X) + self.regexdisplay.focus_set() + + self.addoptions() + + self.statusdisplay = Label(self.master, text="", anchor=W) + self.statusdisplay.pack(side=TOP, fill=X) + + self.labeldisplay = Label(self.master, anchor=W, + text="Enter a string to search:") + self.labeldisplay.pack(fill=X) + self.labeldisplay.pack(fill=X) + + self.showframe = Frame(master) + self.showframe.pack(fill=X, anchor=W) + + self.showvar = StringVar(master) + self.showvar.set("first") + + self.showfirstradio = Radiobutton(self.showframe, + text="Highlight first match", + variable=self.showvar, + value="first", + command=self.recompile) + self.showfirstradio.pack(side=LEFT) + + self.showallradio = Radiobutton(self.showframe, + text="Highlight all matches", + variable=self.showvar, + value="all", + command=self.recompile) + self.showallradio.pack(side=LEFT) + + self.stringdisplay = Text(self.master, width=60, height=4) + self.stringdisplay.pack(fill=BOTH, expand=1) + self.stringdisplay.tag_configure("hit", background="yellow") + + self.grouplabel = Label(self.master, text="Groups:", anchor=W) + self.grouplabel.pack(fill=X) + + self.grouplist = Listbox(self.master) + self.grouplist.pack(expand=1, fill=BOTH) + + self.regexdisplay.bind('', self.recompile) + self.stringdisplay.bind('', self.reevaluate) + + self.compiled = None + self.recompile() + + btags = self.regexdisplay.bindtags() + self.regexdisplay.bindtags(btags[1:] + btags[:1]) + + btags = self.stringdisplay.bindtags() + self.stringdisplay.bindtags(btags[1:] + btags[:1]) + + def addoptions(self): + self.frames = [] + self.boxes = [] + self.vars = [] + for name in ('IGNORECASE', + 'MULTILINE', + 'DOTALL', + 'VERBOSE'): + if len(self.boxes) % 3 == 0: + frame = Frame(self.master) + frame.pack(fill=X) + self.frames.append(frame) + val = getattr(re, name).value + var = IntVar() + box = Checkbutton(frame, + variable=var, text=name, + offvalue=0, onvalue=val, + command=self.recompile) + box.pack(side=LEFT) + self.boxes.append(box) + self.vars.append(var) + + def getflags(self): + flags = 0 + for var in self.vars: + flags = flags | var.get() + return flags + + def recompile(self, event=None): + try: + self.compiled = re.compile(self.regexdisplay.get(), + self.getflags()) + bg = self.promptdisplay['background'] + self.statusdisplay.config(text="", background=bg) + except re.error as msg: + self.compiled = None + self.statusdisplay.config( + text="re.error: %s" % str(msg), + background="red") + self.reevaluate() + + def reevaluate(self, event=None): + try: + self.stringdisplay.tag_remove("hit", "1.0", END) + except TclError: + pass + try: + self.stringdisplay.tag_remove("hit0", "1.0", END) + except TclError: + pass + self.grouplist.delete(0, END) + if not self.compiled: + return + self.stringdisplay.tag_configure("hit", background="yellow") + self.stringdisplay.tag_configure("hit0", background="orange") + text = self.stringdisplay.get("1.0", END) + last = 0 + nmatches = 0 + while last <= len(text): + m = self.compiled.search(text, last) + if m is None: + break + first, last = m.span() + if last == first: + last = first+1 + tag = "hit0" + else: + tag = "hit" + pfirst = "1.0 + %d chars" % first + plast = "1.0 + %d chars" % last + self.stringdisplay.tag_add(tag, pfirst, plast) + if nmatches == 0: + self.stringdisplay.yview_pickplace(pfirst) + groups = list(m.groups()) + groups.insert(0, m.group()) + for i in range(len(groups)): + g = "%2d: %r" % (i, groups[i]) + self.grouplist.insert(END, g) + nmatches = nmatches + 1 + if self.showvar.get() == "first": + break + + if nmatches == 0: + self.statusdisplay.config(text="(no match)", + background="yellow") + else: + self.statusdisplay.config(text="") + + +# Main function, run when invoked as a stand-alone Python program. + +def main(): + root = Tk() + demo = ReDemo(root) + root.protocol('WM_DELETE_WINDOW', root.quit) + root.mainloop() + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/demo/rpython.py b/marketing/Tools/demo/rpython.py new file mode 100644 index 0000000000000000000000000000000000000000..11f72cb3dd26a61b9e1b1896970f52c3cebfa501 --- /dev/null +++ b/marketing/Tools/demo/rpython.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 + +""" +Remote python client. +Execute Python commands remotely and send output back. +""" + +import sys +from socket import socket, AF_INET, SOCK_STREAM, SHUT_WR + +PORT = 4127 +BUFSIZE = 1024 + +def main(): + if len(sys.argv) < 3: + print("usage: rpython host command") + sys.exit(2) + host = sys.argv[1] + port = PORT + i = host.find(':') + if i >= 0: + port = int(host[i+1:]) + host = host[:i] + command = ' '.join(sys.argv[2:]) + with socket(AF_INET, SOCK_STREAM) as s: + s.connect((host, port)) + s.send(command.encode()) + s.shutdown(SHUT_WR) + reply = b'' + while True: + data = s.recv(BUFSIZE) + if not data: + break + reply += data + print(reply.decode(), end=' ') + +main() diff --git a/marketing/Tools/demo/rpythond.py b/marketing/Tools/demo/rpythond.py new file mode 100644 index 0000000000000000000000000000000000000000..a18de137fa1cf888e43c2824923de235f8e52af3 --- /dev/null +++ b/marketing/Tools/demo/rpythond.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 + +""" +Remote python server. +Execute Python commands remotely and send output back. + +WARNING: This version has a gaping security hole -- it accepts requests +from any host on the Internet! +""" + +import sys +from socket import socket, AF_INET, SOCK_STREAM +import io +import traceback + +PORT = 4127 +BUFSIZE = 1024 + +def main(): + if len(sys.argv) > 1: + port = int(sys.argv[1]) + else: + port = PORT + s = socket(AF_INET, SOCK_STREAM) + s.bind(('', port)) + s.listen(1) + while True: + conn, (remotehost, remoteport) = s.accept() + with conn: + print('connection from', remotehost, remoteport) + request = b'' + while True: + data = conn.recv(BUFSIZE) + if not data: + break + request += data + reply = execute(request.decode()) + conn.send(reply.encode()) + +def execute(request): + stdout = sys.stdout + stderr = sys.stderr + sys.stdout = sys.stderr = fakefile = io.StringIO() + try: + try: + exec(request, {}, {}) + except: + print() + traceback.print_exc(100) + finally: + sys.stderr = stderr + sys.stdout = stdout + return fakefile.getvalue() + +try: + main() +except KeyboardInterrupt: + pass diff --git a/marketing/Tools/demo/sortvisu.py b/marketing/Tools/demo/sortvisu.py new file mode 100644 index 0000000000000000000000000000000000000000..056a0e05fb1ed2e988262d3baf0ec0a08699fefa --- /dev/null +++ b/marketing/Tools/demo/sortvisu.py @@ -0,0 +1,635 @@ +#!/usr/bin/env python3 + +""" +Sorting algorithms visualizer using Tkinter. + +This module is comprised of three ``components'': + +- an array visualizer with methods that implement basic sorting +operations (compare, swap) as well as methods for ``annotating'' the +sorting algorithm (e.g. to show the pivot element); + +- a number of sorting algorithms (currently quicksort, insertion sort, +selection sort and bubble sort, as well as a randomization function), +all using the array visualizer for its basic operations and with calls +to its annotation methods; + +- and a ``driver'' class which can be used as a Grail applet or as a +stand-alone application. +""" + +from tkinter import * +import random + +XGRID = 10 +YGRID = 10 +WIDTH = 6 + + +class Array: + + class Cancelled(BaseException): + pass + + def __init__(self, master, data=None): + self.master = master + self.frame = Frame(self.master) + self.frame.pack(fill=X) + self.label = Label(self.frame) + self.label.pack() + self.canvas = Canvas(self.frame) + self.canvas.pack() + self.report = Label(self.frame) + self.report.pack() + self.left = self.canvas.create_line(0, 0, 0, 0) + self.right = self.canvas.create_line(0, 0, 0, 0) + self.pivot = self.canvas.create_line(0, 0, 0, 0) + self.items = [] + self.size = self.maxvalue = 0 + if data: + self.setdata(data) + + def setdata(self, data): + olditems = self.items + self.items = [] + for item in olditems: + item.delete() + self.size = len(data) + self.maxvalue = max(data) + self.canvas.config(width=(self.size+1)*XGRID, + height=(self.maxvalue+1)*YGRID) + for i in range(self.size): + self.items.append(ArrayItem(self, i, data[i])) + self.reset("Sort demo, size %d" % self.size) + + speed = "normal" + + def setspeed(self, speed): + self.speed = speed + + def destroy(self): + self.frame.destroy() + + in_mainloop = 0 + stop_mainloop = 0 + + def cancel(self): + self.stop_mainloop = 1 + if self.in_mainloop: + self.master.quit() + + def step(self): + if self.in_mainloop: + self.master.quit() + + def wait(self, msecs): + if self.speed == "fastest": + msecs = 0 + elif self.speed == "fast": + msecs = msecs//10 + elif self.speed == "single-step": + msecs = 1000000000 + if not self.stop_mainloop: + self.master.update() + id = self.master.after(msecs, self.master.quit) + self.in_mainloop = 1 + self.master.mainloop() + self.master.after_cancel(id) + self.in_mainloop = 0 + if self.stop_mainloop: + self.stop_mainloop = 0 + self.message("Cancelled") + raise Array.Cancelled + + def getsize(self): + return self.size + + def show_partition(self, first, last): + for i in range(self.size): + item = self.items[i] + if first <= i < last: + self.canvas.itemconfig(item, fill='red') + else: + self.canvas.itemconfig(item, fill='orange') + self.hide_left_right_pivot() + + def hide_partition(self): + for i in range(self.size): + item = self.items[i] + self.canvas.itemconfig(item, fill='red') + self.hide_left_right_pivot() + + def show_left(self, left): + if not 0 <= left < self.size: + self.hide_left() + return + x1, y1, x2, y2 = self.items[left].position() +## top, bot = HIRO + self.canvas.coords(self.left, (x1 - 2, 0, x1 - 2, 9999)) + self.master.update() + + def show_right(self, right): + if not 0 <= right < self.size: + self.hide_right() + return + x1, y1, x2, y2 = self.items[right].position() + self.canvas.coords(self.right, (x2 + 2, 0, x2 + 2, 9999)) + self.master.update() + + def hide_left_right_pivot(self): + self.hide_left() + self.hide_right() + self.hide_pivot() + + def hide_left(self): + self.canvas.coords(self.left, (0, 0, 0, 0)) + + def hide_right(self): + self.canvas.coords(self.right, (0, 0, 0, 0)) + + def show_pivot(self, pivot): + x1, y1, x2, y2 = self.items[pivot].position() + self.canvas.coords(self.pivot, (0, y1 - 2, 9999, y1 - 2)) + + def hide_pivot(self): + self.canvas.coords(self.pivot, (0, 0, 0, 0)) + + def swap(self, i, j): + if i == j: return + self.countswap() + item = self.items[i] + other = self.items[j] + self.items[i], self.items[j] = other, item + item.swapwith(other) + + def compare(self, i, j): + self.countcompare() + item = self.items[i] + other = self.items[j] + return item.compareto(other) + + def reset(self, msg): + self.ncompares = 0 + self.nswaps = 0 + self.message(msg) + self.updatereport() + self.hide_partition() + + def message(self, msg): + self.label.config(text=msg) + + def countswap(self): + self.nswaps = self.nswaps + 1 + self.updatereport() + + def countcompare(self): + self.ncompares = self.ncompares + 1 + self.updatereport() + + def updatereport(self): + text = "%d cmps, %d swaps" % (self.ncompares, self.nswaps) + self.report.config(text=text) + + +class ArrayItem: + + def __init__(self, array, index, value): + self.array = array + self.index = index + self.value = value + self.canvas = array.canvas + x1, y1, x2, y2 = self.position() + self.item_id = array.canvas.create_rectangle(x1, y1, x2, y2, + fill='red', outline='black', width=1) + self.canvas.tag_bind(self.item_id, '', self.mouse_down) + self.canvas.tag_bind(self.item_id, '', self.mouse_move) + self.canvas.tag_bind(self.item_id, '', self.mouse_up) + + def delete(self): + item_id = self.item_id + self.array = None + self.item_id = None + self.canvas.delete(item_id) + + def mouse_down(self, event): + self.lastx = event.x + self.lasty = event.y + self.origx = event.x + self.origy = event.y + self.canvas.tag_raise(self.item_id) + + def mouse_move(self, event): + self.canvas.move(self.item_id, + event.x - self.lastx, event.y - self.lasty) + self.lastx = event.x + self.lasty = event.y + + def mouse_up(self, event): + i = self.nearestindex(event.x) + if i >= self.array.getsize(): + i = self.array.getsize() - 1 + if i < 0: + i = 0 + other = self.array.items[i] + here = self.index + self.array.items[here], self.array.items[i] = other, self + self.index = i + x1, y1, x2, y2 = self.position() + self.canvas.coords(self.item_id, (x1, y1, x2, y2)) + other.setindex(here) + + def setindex(self, index): + nsteps = steps(self.index, index) + if not nsteps: return + if self.array.speed == "fastest": + nsteps = 0 + oldpts = self.position() + self.index = index + newpts = self.position() + trajectory = interpolate(oldpts, newpts, nsteps) + self.canvas.tag_raise(self.item_id) + for pts in trajectory: + self.canvas.coords(self.item_id, pts) + self.array.wait(50) + + def swapwith(self, other): + nsteps = steps(self.index, other.index) + if not nsteps: return + if self.array.speed == "fastest": + nsteps = 0 + myoldpts = self.position() + otheroldpts = other.position() + self.index, other.index = other.index, self.index + mynewpts = self.position() + othernewpts = other.position() + myfill = self.canvas.itemcget(self.item_id, 'fill') + otherfill = self.canvas.itemcget(other.item_id, 'fill') + self.canvas.itemconfig(self.item_id, fill='green') + self.canvas.itemconfig(other.item_id, fill='yellow') + self.array.master.update() + if self.array.speed == "single-step": + self.canvas.coords(self.item_id, mynewpts) + self.canvas.coords(other.item_id, othernewpts) + self.array.master.update() + self.canvas.itemconfig(self.item_id, fill=myfill) + self.canvas.itemconfig(other.item_id, fill=otherfill) + self.array.wait(0) + return + mytrajectory = interpolate(myoldpts, mynewpts, nsteps) + othertrajectory = interpolate(otheroldpts, othernewpts, nsteps) + if self.value > other.value: + self.canvas.tag_raise(self.item_id) + self.canvas.tag_raise(other.item_id) + else: + self.canvas.tag_raise(other.item_id) + self.canvas.tag_raise(self.item_id) + try: + for i in range(len(mytrajectory)): + mypts = mytrajectory[i] + otherpts = othertrajectory[i] + self.canvas.coords(self.item_id, mypts) + self.canvas.coords(other.item_id, otherpts) + self.array.wait(50) + finally: + mypts = mytrajectory[-1] + otherpts = othertrajectory[-1] + self.canvas.coords(self.item_id, mypts) + self.canvas.coords(other.item_id, otherpts) + self.canvas.itemconfig(self.item_id, fill=myfill) + self.canvas.itemconfig(other.item_id, fill=otherfill) + + def compareto(self, other): + myfill = self.canvas.itemcget(self.item_id, 'fill') + otherfill = self.canvas.itemcget(other.item_id, 'fill') + if self.value < other.value: + myflash = 'white' + otherflash = 'black' + outcome = -1 + elif self.value > other.value: + myflash = 'black' + otherflash = 'white' + outcome = 1 + else: + myflash = otherflash = 'grey' + outcome = 0 + try: + self.canvas.itemconfig(self.item_id, fill=myflash) + self.canvas.itemconfig(other.item_id, fill=otherflash) + self.array.wait(500) + finally: + self.canvas.itemconfig(self.item_id, fill=myfill) + self.canvas.itemconfig(other.item_id, fill=otherfill) + return outcome + + def position(self): + x1 = (self.index+1)*XGRID - WIDTH//2 + x2 = x1+WIDTH + y2 = (self.array.maxvalue+1)*YGRID + y1 = y2 - (self.value)*YGRID + return x1, y1, x2, y2 + + def nearestindex(self, x): + return int(round(float(x)/XGRID)) - 1 + + +# Subroutines that don't need an object + +def steps(here, there): + nsteps = abs(here - there) + if nsteps <= 3: + nsteps = nsteps * 3 + elif nsteps <= 5: + nsteps = nsteps * 2 + elif nsteps > 10: + nsteps = 10 + return nsteps + +def interpolate(oldpts, newpts, n): + if len(oldpts) != len(newpts): + raise ValueError("can't interpolate arrays of different length") + pts = [0]*len(oldpts) + res = [tuple(oldpts)] + for i in range(1, n): + for k in range(len(pts)): + pts[k] = oldpts[k] + (newpts[k] - oldpts[k])*i//n + res.append(tuple(pts)) + res.append(tuple(newpts)) + return res + + +# Various (un)sorting algorithms + +def uniform(array): + size = array.getsize() + array.setdata([(size+1)//2] * size) + array.reset("Uniform data, size %d" % size) + +def distinct(array): + size = array.getsize() + array.setdata(range(1, size+1)) + array.reset("Distinct data, size %d" % size) + +def randomize(array): + array.reset("Randomizing") + n = array.getsize() + for i in range(n): + j = random.randint(0, n-1) + array.swap(i, j) + array.message("Randomized") + +def insertionsort(array): + size = array.getsize() + array.reset("Insertion sort") + for i in range(1, size): + j = i-1 + while j >= 0: + if array.compare(j, j+1) <= 0: + break + array.swap(j, j+1) + j = j-1 + array.message("Sorted") + +def selectionsort(array): + size = array.getsize() + array.reset("Selection sort") + try: + for i in range(size): + array.show_partition(i, size) + for j in range(i+1, size): + if array.compare(i, j) > 0: + array.swap(i, j) + array.message("Sorted") + finally: + array.hide_partition() + +def bubblesort(array): + size = array.getsize() + array.reset("Bubble sort") + for i in range(size): + for j in range(1, size): + if array.compare(j-1, j) > 0: + array.swap(j-1, j) + array.message("Sorted") + +def quicksort(array): + size = array.getsize() + array.reset("Quicksort") + try: + stack = [(0, size)] + while stack: + first, last = stack[-1] + del stack[-1] + array.show_partition(first, last) + if last-first < 5: + array.message("Insertion sort") + for i in range(first+1, last): + j = i-1 + while j >= first: + if array.compare(j, j+1) <= 0: + break + array.swap(j, j+1) + j = j-1 + continue + array.message("Choosing pivot") + j, i, k = first, (first+last) // 2, last-1 + if array.compare(k, i) < 0: + array.swap(k, i) + if array.compare(k, j) < 0: + array.swap(k, j) + if array.compare(j, i) < 0: + array.swap(j, i) + pivot = j + array.show_pivot(pivot) + array.message("Pivot at left of partition") + array.wait(1000) + left = first + right = last + while True: + array.message("Sweep right pointer") + right = right-1 + array.show_right(right) + while right > first and array.compare(right, pivot) >= 0: + right = right-1 + array.show_right(right) + array.message("Sweep left pointer") + left = left+1 + array.show_left(left) + while left < last and array.compare(left, pivot) <= 0: + left = left+1 + array.show_left(left) + if left > right: + array.message("End of partition") + break + array.message("Swap items") + array.swap(left, right) + array.message("Swap pivot back") + array.swap(pivot, right) + n1 = right-first + n2 = last-left + if n1 > 1: stack.append((first, right)) + if n2 > 1: stack.append((left, last)) + array.message("Sorted") + finally: + array.hide_partition() + +def demosort(array): + while True: + for alg in [quicksort, insertionsort, selectionsort, bubblesort]: + randomize(array) + alg(array) + + +# Sort demo class -- usable as a Grail applet + +class SortDemo: + + def __init__(self, master, size=15): + self.master = master + self.size = size + self.busy = 0 + self.array = Array(self.master) + + self.botframe = Frame(master) + self.botframe.pack(side=BOTTOM) + self.botleftframe = Frame(self.botframe) + self.botleftframe.pack(side=LEFT, fill=Y) + self.botrightframe = Frame(self.botframe) + self.botrightframe.pack(side=RIGHT, fill=Y) + + self.b_qsort = Button(self.botleftframe, + text="Quicksort", command=self.c_qsort) + self.b_qsort.pack(fill=X) + self.b_isort = Button(self.botleftframe, + text="Insertion sort", command=self.c_isort) + self.b_isort.pack(fill=X) + self.b_ssort = Button(self.botleftframe, + text="Selection sort", command=self.c_ssort) + self.b_ssort.pack(fill=X) + self.b_bsort = Button(self.botleftframe, + text="Bubble sort", command=self.c_bsort) + self.b_bsort.pack(fill=X) + + # Terrible hack to overcome limitation of OptionMenu... + class MyIntVar(IntVar): + def __init__(self, master, demo): + self.demo = demo + IntVar.__init__(self, master) + def set(self, value): + IntVar.set(self, value) + if str(value) != '0': + self.demo.resize(value) + + self.v_size = MyIntVar(self.master, self) + self.v_size.set(size) + sizes = [1, 2, 3, 4] + list(range(5, 55, 5)) + if self.size not in sizes: + sizes.append(self.size) + sizes.sort() + self.m_size = OptionMenu(self.botleftframe, self.v_size, *sizes) + self.m_size.pack(fill=X) + + self.v_speed = StringVar(self.master) + self.v_speed.set("normal") + self.m_speed = OptionMenu(self.botleftframe, self.v_speed, + "single-step", "normal", "fast", "fastest") + self.m_speed.pack(fill=X) + + self.b_step = Button(self.botleftframe, + text="Step", command=self.c_step) + self.b_step.pack(fill=X) + + self.b_randomize = Button(self.botrightframe, + text="Randomize", command=self.c_randomize) + self.b_randomize.pack(fill=X) + self.b_uniform = Button(self.botrightframe, + text="Uniform", command=self.c_uniform) + self.b_uniform.pack(fill=X) + self.b_distinct = Button(self.botrightframe, + text="Distinct", command=self.c_distinct) + self.b_distinct.pack(fill=X) + self.b_demo = Button(self.botrightframe, + text="Demo", command=self.c_demo) + self.b_demo.pack(fill=X) + self.b_cancel = Button(self.botrightframe, + text="Cancel", command=self.c_cancel) + self.b_cancel.pack(fill=X) + self.b_cancel.config(state=DISABLED) + self.b_quit = Button(self.botrightframe, + text="Quit", command=self.c_quit) + self.b_quit.pack(fill=X) + + def resize(self, newsize): + if self.busy: + self.master.bell() + return + self.size = newsize + self.array.setdata(range(1, self.size+1)) + + def c_qsort(self): + self.run(quicksort) + + def c_isort(self): + self.run(insertionsort) + + def c_ssort(self): + self.run(selectionsort) + + def c_bsort(self): + self.run(bubblesort) + + def c_demo(self): + self.run(demosort) + + def c_randomize(self): + self.run(randomize) + + def c_uniform(self): + self.run(uniform) + + def c_distinct(self): + self.run(distinct) + + def run(self, func): + if self.busy: + self.master.bell() + return + self.busy = 1 + self.array.setspeed(self.v_speed.get()) + self.b_cancel.config(state=NORMAL) + try: + func(self.array) + except Array.Cancelled: + pass + self.b_cancel.config(state=DISABLED) + self.busy = 0 + + def c_cancel(self): + if not self.busy: + self.master.bell() + return + self.array.cancel() + + def c_step(self): + if not self.busy: + self.master.bell() + return + self.v_speed.set("single-step") + self.array.setspeed("single-step") + self.array.step() + + def c_quit(self): + if self.busy: + self.array.cancel() + self.master.after_idle(self.master.quit) + + +# Main program -- for stand-alone operation outside Grail + +def main(): + root = Tk() + demo = SortDemo(root) + root.protocol('WM_DELETE_WINDOW', demo.c_quit) + root.mainloop() + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/demo/spreadsheet.py b/marketing/Tools/demo/spreadsheet.py new file mode 100644 index 0000000000000000000000000000000000000000..bf88820dca3471687da24a2ec56d03d8af599927 --- /dev/null +++ b/marketing/Tools/demo/spreadsheet.py @@ -0,0 +1,829 @@ +#!/usr/bin/env python3 + +""" +SS1 -- a spreadsheet-like application. +""" + +import os +import re +import sys +from xml.parsers import expat +from xml.sax.saxutils import escape + +LEFT, CENTER, RIGHT = "LEFT", "CENTER", "RIGHT" + +def ljust(x, n): + return x.ljust(n) +def center(x, n): + return x.center(n) +def rjust(x, n): + return x.rjust(n) +align2action = {LEFT: ljust, CENTER: center, RIGHT: rjust} + +align2xml = {LEFT: "left", CENTER: "center", RIGHT: "right"} +xml2align = {"left": LEFT, "center": CENTER, "right": RIGHT} + +align2anchor = {LEFT: "w", CENTER: "center", RIGHT: "e"} + +def sum(seq): + total = 0 + for x in seq: + if x is not None: + total += x + return total + +class Sheet: + + def __init__(self): + self.cells = {} # {(x, y): cell, ...} + self.ns = dict( + cell = self.cellvalue, + cells = self.multicellvalue, + sum = sum, + ) + + def cellvalue(self, x, y): + cell = self.getcell(x, y) + if hasattr(cell, 'recalc'): + return cell.recalc(self.ns) + else: + return cell + + def multicellvalue(self, x1, y1, x2, y2): + if x1 > x2: + x1, x2 = x2, x1 + if y1 > y2: + y1, y2 = y2, y1 + seq = [] + for y in range(y1, y2+1): + for x in range(x1, x2+1): + seq.append(self.cellvalue(x, y)) + return seq + + def getcell(self, x, y): + return self.cells.get((x, y)) + + def setcell(self, x, y, cell): + assert x > 0 and y > 0 + assert isinstance(cell, BaseCell) + self.cells[x, y] = cell + + def clearcell(self, x, y): + try: + del self.cells[x, y] + except KeyError: + pass + + def clearcells(self, x1, y1, x2, y2): + for xy in self.selectcells(x1, y1, x2, y2): + del self.cells[xy] + + def clearrows(self, y1, y2): + self.clearcells(0, y1, sys.maxsize, y2) + + def clearcolumns(self, x1, x2): + self.clearcells(x1, 0, x2, sys.maxsize) + + def selectcells(self, x1, y1, x2, y2): + if x1 > x2: + x1, x2 = x2, x1 + if y1 > y2: + y1, y2 = y2, y1 + return [(x, y) for x, y in self.cells + if x1 <= x <= x2 and y1 <= y <= y2] + + def movecells(self, x1, y1, x2, y2, dx, dy): + if dx == 0 and dy == 0: + return + if x1 > x2: + x1, x2 = x2, x1 + if y1 > y2: + y1, y2 = y2, y1 + assert x1+dx > 0 and y1+dy > 0 + new = {} + for x, y in self.cells: + cell = self.cells[x, y] + if hasattr(cell, 'renumber'): + cell = cell.renumber(x1, y1, x2, y2, dx, dy) + if x1 <= x <= x2 and y1 <= y <= y2: + x += dx + y += dy + new[x, y] = cell + self.cells = new + + def insertrows(self, y, n): + assert n > 0 + self.movecells(0, y, sys.maxsize, sys.maxsize, 0, n) + + def deleterows(self, y1, y2): + if y1 > y2: + y1, y2 = y2, y1 + self.clearrows(y1, y2) + self.movecells(0, y2+1, sys.maxsize, sys.maxsize, 0, y1-y2-1) + + def insertcolumns(self, x, n): + assert n > 0 + self.movecells(x, 0, sys.maxsize, sys.maxsize, n, 0) + + def deletecolumns(self, x1, x2): + if x1 > x2: + x1, x2 = x2, x1 + self.clearcells(x1, x2) + self.movecells(x2+1, 0, sys.maxsize, sys.maxsize, x1-x2-1, 0) + + def getsize(self): + maxx = maxy = 0 + for x, y in self.cells: + maxx = max(maxx, x) + maxy = max(maxy, y) + return maxx, maxy + + def reset(self): + for cell in self.cells.values(): + if hasattr(cell, 'reset'): + cell.reset() + + def recalc(self): + self.reset() + for cell in self.cells.values(): + if hasattr(cell, 'recalc'): + cell.recalc(self.ns) + + def display(self): + maxx, maxy = self.getsize() + width, height = maxx+1, maxy+1 + colwidth = [1] * width + full = {} + # Add column heading labels in row 0 + for x in range(1, width): + full[x, 0] = text, alignment = colnum2name(x), RIGHT + colwidth[x] = max(colwidth[x], len(text)) + # Add row labels in column 0 + for y in range(1, height): + full[0, y] = text, alignment = str(y), RIGHT + colwidth[0] = max(colwidth[0], len(text)) + # Add sheet cells in columns with x>0 and y>0 + for (x, y), cell in self.cells.items(): + if x <= 0 or y <= 0: + continue + if hasattr(cell, 'recalc'): + cell.recalc(self.ns) + if hasattr(cell, 'format'): + text, alignment = cell.format() + assert isinstance(text, str) + assert alignment in (LEFT, CENTER, RIGHT) + else: + text = str(cell) + if isinstance(cell, str): + alignment = LEFT + else: + alignment = RIGHT + full[x, y] = (text, alignment) + colwidth[x] = max(colwidth[x], len(text)) + # Calculate the horizontal separator line (dashes and dots) + sep = "" + for x in range(width): + if sep: + sep += "+" + sep += "-"*colwidth[x] + # Now print The full grid + for y in range(height): + line = "" + for x in range(width): + text, alignment = full.get((x, y)) or ("", LEFT) + text = align2action[alignment](text, colwidth[x]) + if line: + line += '|' + line += text + print(line) + if y == 0: + print(sep) + + def xml(self): + out = [''] + for (x, y), cell in self.cells.items(): + if hasattr(cell, 'xml'): + cellxml = cell.xml() + else: + cellxml = '%s' % escape(cell) + out.append('\n %s\n' % + (y, x, cellxml)) + out.append('') + return '\n'.join(out) + + def save(self, filename): + text = self.xml() + with open(filename, "w", encoding='utf-8') as f: + f.write(text) + if text and not text.endswith('\n'): + f.write('\n') + + def load(self, filename): + with open(filename, 'rb') as f: + SheetParser(self).parsefile(f) + +class SheetParser: + + def __init__(self, sheet): + self.sheet = sheet + + def parsefile(self, f): + parser = expat.ParserCreate() + parser.StartElementHandler = self.startelement + parser.EndElementHandler = self.endelement + parser.CharacterDataHandler = self.data + parser.ParseFile(f) + + def startelement(self, tag, attrs): + method = getattr(self, 'start_'+tag, None) + if method: + method(attrs) + self.texts = [] + + def data(self, text): + self.texts.append(text) + + def endelement(self, tag): + method = getattr(self, 'end_'+tag, None) + if method: + method("".join(self.texts)) + + def start_cell(self, attrs): + self.y = int(attrs.get("row")) + self.x = int(attrs.get("col")) + + def start_value(self, attrs): + self.fmt = attrs.get('format') + self.alignment = xml2align.get(attrs.get('align')) + + start_formula = start_value + + def end_int(self, text): + try: + self.value = int(text) + except (TypeError, ValueError): + self.value = None + + end_long = end_int + + def end_double(self, text): + try: + self.value = float(text) + except (TypeError, ValueError): + self.value = None + + def end_complex(self, text): + try: + self.value = complex(text) + except (TypeError, ValueError): + self.value = None + + def end_string(self, text): + self.value = text + + def end_value(self, text): + if isinstance(self.value, BaseCell): + self.cell = self.value + elif isinstance(self.value, str): + self.cell = StringCell(self.value, + self.fmt or "%s", + self.alignment or LEFT) + else: + self.cell = NumericCell(self.value, + self.fmt or "%s", + self.alignment or RIGHT) + + def end_formula(self, text): + self.cell = FormulaCell(text, + self.fmt or "%s", + self.alignment or RIGHT) + + def end_cell(self, text): + self.sheet.setcell(self.x, self.y, self.cell) + +class BaseCell: + __init__ = None # Must provide + """Abstract base class for sheet cells. + + Subclasses may but needn't provide the following APIs: + + cell.reset() -- prepare for recalculation + cell.recalc(ns) -> value -- recalculate formula + cell.format() -> (value, alignment) -- return formatted value + cell.xml() -> string -- return XML + """ + +class NumericCell(BaseCell): + + def __init__(self, value, fmt="%s", alignment=RIGHT): + assert isinstance(value, (int, float, complex)) + assert alignment in (LEFT, CENTER, RIGHT) + self.value = value + self.fmt = fmt + self.alignment = alignment + + def recalc(self, ns): + return self.value + + def format(self): + try: + text = self.fmt % self.value + except: + text = str(self.value) + return text, self.alignment + + def xml(self): + method = getattr(self, '_xml_' + type(self.value).__name__) + return '%s' % ( + align2xml[self.alignment], + self.fmt, + method()) + + def _xml_int(self): + if -2**31 <= self.value < 2**31: + return '%s' % self.value + else: + return '%s' % self.value + + def _xml_float(self): + return '%r' % self.value + + def _xml_complex(self): + return '%r' % self.value + +class StringCell(BaseCell): + + def __init__(self, text, fmt="%s", alignment=LEFT): + assert isinstance(text, str) + assert alignment in (LEFT, CENTER, RIGHT) + self.text = text + self.fmt = fmt + self.alignment = alignment + + def recalc(self, ns): + return self.text + + def format(self): + return self.text, self.alignment + + def xml(self): + s = '%s' + return s % ( + align2xml[self.alignment], + self.fmt, + escape(self.text)) + +class FormulaCell(BaseCell): + + def __init__(self, formula, fmt="%s", alignment=RIGHT): + assert alignment in (LEFT, CENTER, RIGHT) + self.formula = formula + self.translated = translate(self.formula) + self.fmt = fmt + self.alignment = alignment + self.reset() + + def reset(self): + self.value = None + + def recalc(self, ns): + if self.value is None: + try: + self.value = eval(self.translated, ns) + except: + exc = sys.exc_info()[0] + if hasattr(exc, "__name__"): + self.value = exc.__name__ + else: + self.value = str(exc) + return self.value + + def format(self): + try: + text = self.fmt % self.value + except: + text = str(self.value) + return text, self.alignment + + def xml(self): + return '%s' % ( + align2xml[self.alignment], + self.fmt, + escape(self.formula)) + + def renumber(self, x1, y1, x2, y2, dx, dy): + out = [] + for part in re.split(r'(\w+)', self.formula): + m = re.match('^([A-Z]+)([1-9][0-9]*)$', part) + if m is not None: + sx, sy = m.groups() + x = colname2num(sx) + y = int(sy) + if x1 <= x <= x2 and y1 <= y <= y2: + part = cellname(x+dx, y+dy) + out.append(part) + return FormulaCell("".join(out), self.fmt, self.alignment) + +def translate(formula): + """Translate a formula containing fancy cell names to valid Python code. + + Examples: + B4 -> cell(2, 4) + B4:Z100 -> cells(2, 4, 26, 100) + """ + out = [] + for part in re.split(r"(\w+(?::\w+)?)", formula): + m = re.match(r"^([A-Z]+)([1-9][0-9]*)(?::([A-Z]+)([1-9][0-9]*))?$", part) + if m is None: + out.append(part) + else: + x1, y1, x2, y2 = m.groups() + x1 = colname2num(x1) + if x2 is None: + s = "cell(%s, %s)" % (x1, y1) + else: + x2 = colname2num(x2) + s = "cells(%s, %s, %s, %s)" % (x1, y1, x2, y2) + out.append(s) + return "".join(out) + +def cellname(x, y): + "Translate a cell coordinate to a fancy cell name (e.g. (1, 1)->'A1')." + assert x > 0 # Column 0 has an empty name, so can't use that + return colnum2name(x) + str(y) + +def colname2num(s): + "Translate a column name to number (e.g. 'A'->1, 'Z'->26, 'AA'->27)." + s = s.upper() + n = 0 + for c in s: + assert 'A' <= c <= 'Z' + n = n*26 + ord(c) - ord('A') + 1 + return n + +def colnum2name(n): + "Translate a column number to name (e.g. 1->'A', etc.)." + assert n > 0 + s = "" + while n: + n, m = divmod(n-1, 26) + s = chr(m+ord('A')) + s + return s + +import tkinter as Tk + +class SheetGUI: + + """Beginnings of a GUI for a spreadsheet. + + TO DO: + - clear multiple cells + - Insert, clear, remove rows or columns + - Show new contents while typing + - Scroll bars + - Grow grid when window is grown + - Proper menus + - Undo, redo + - Cut, copy and paste + - Formatting and alignment + """ + + def __init__(self, filename="sheet1.xml", rows=10, columns=5): + """Constructor. + + Load the sheet from the filename argument. + Set up the Tk widget tree. + """ + # Create and load the sheet + self.filename = filename + self.sheet = Sheet() + if os.path.isfile(filename): + self.sheet.load(filename) + # Calculate the needed grid size + maxx, maxy = self.sheet.getsize() + rows = max(rows, maxy) + columns = max(columns, maxx) + # Create the widgets + self.root = Tk.Tk() + self.root.wm_title("Spreadsheet: %s" % self.filename) + self.beacon = Tk.Label(self.root, text="A1", + font=('helvetica', 16, 'bold')) + self.entry = Tk.Entry(self.root) + self.savebutton = Tk.Button(self.root, text="Save", + command=self.save) + self.cellgrid = Tk.Frame(self.root) + # Configure the widget lay-out + self.cellgrid.pack(side="bottom", expand=1, fill="both") + self.beacon.pack(side="left") + self.savebutton.pack(side="right") + self.entry.pack(side="left", expand=1, fill="x") + # Bind some events + self.entry.bind("", self.return_event) + self.entry.bind("", self.shift_return_event) + self.entry.bind("", self.tab_event) + self.entry.bind("", self.shift_tab_event) + self.entry.bind("", self.delete_event) + self.entry.bind("", self.escape_event) + # Now create the cell grid + self.makegrid(rows, columns) + # Select the top-left cell + self.currentxy = None + self.cornerxy = None + self.setcurrent(1, 1) + # Copy the sheet cells to the GUI cells + self.sync() + + def delete_event(self, event): + if self.cornerxy != self.currentxy and self.cornerxy is not None: + self.sheet.clearcells(*(self.currentxy + self.cornerxy)) + else: + self.sheet.clearcell(*self.currentxy) + self.sync() + self.entry.delete(0, 'end') + return "break" + + def escape_event(self, event): + x, y = self.currentxy + self.load_entry(x, y) + + def load_entry(self, x, y): + cell = self.sheet.getcell(x, y) + if cell is None: + text = "" + elif isinstance(cell, FormulaCell): + text = '=' + cell.formula + else: + text, alignment = cell.format() + self.entry.delete(0, 'end') + self.entry.insert(0, text) + self.entry.selection_range(0, 'end') + + def makegrid(self, rows, columns): + """Helper to create the grid of GUI cells. + + The edge (x==0 or y==0) is filled with labels; the rest is real cells. + """ + self.rows = rows + self.columns = columns + self.gridcells = {} + # Create the top left corner cell (which selects all) + cell = Tk.Label(self.cellgrid, relief='raised') + cell.grid_configure(column=0, row=0, sticky='NSWE') + cell.bind("", self.selectall) + # Create the top row of labels, and configure the grid columns + for x in range(1, columns+1): + self.cellgrid.grid_columnconfigure(x, minsize=64) + cell = Tk.Label(self.cellgrid, text=colnum2name(x), relief='raised') + cell.grid_configure(column=x, row=0, sticky='WE') + self.gridcells[x, 0] = cell + cell.__x = x + cell.__y = 0 + cell.bind("", self.selectcolumn) + cell.bind("", self.extendcolumn) + cell.bind("", self.extendcolumn) + cell.bind("", self.extendcolumn) + # Create the leftmost column of labels + for y in range(1, rows+1): + cell = Tk.Label(self.cellgrid, text=str(y), relief='raised') + cell.grid_configure(column=0, row=y, sticky='WE') + self.gridcells[0, y] = cell + cell.__x = 0 + cell.__y = y + cell.bind("", self.selectrow) + cell.bind("", self.extendrow) + cell.bind("", self.extendrow) + cell.bind("", self.extendrow) + # Create the real cells + for x in range(1, columns+1): + for y in range(1, rows+1): + cell = Tk.Label(self.cellgrid, relief='sunken', + bg='white', fg='black') + cell.grid_configure(column=x, row=y, sticky='NSWE') + self.gridcells[x, y] = cell + cell.__x = x + cell.__y = y + # Bind mouse events + cell.bind("", self.press) + cell.bind("", self.motion) + cell.bind("", self.release) + cell.bind("", self.release) + + def selectall(self, event): + self.setcurrent(1, 1) + self.setcorner(sys.maxsize, sys.maxsize) + + def selectcolumn(self, event): + x, y = self.whichxy(event) + self.setcurrent(x, 1) + self.setcorner(x, sys.maxsize) + + def extendcolumn(self, event): + x, y = self.whichxy(event) + if x > 0: + self.setcurrent(self.currentxy[0], 1) + self.setcorner(x, sys.maxsize) + + def selectrow(self, event): + x, y = self.whichxy(event) + self.setcurrent(1, y) + self.setcorner(sys.maxsize, y) + + def extendrow(self, event): + x, y = self.whichxy(event) + if y > 0: + self.setcurrent(1, self.currentxy[1]) + self.setcorner(sys.maxsize, y) + + def press(self, event): + x, y = self.whichxy(event) + if x > 0 and y > 0: + self.setcurrent(x, y) + + def motion(self, event): + x, y = self.whichxy(event) + if x > 0 and y > 0: + self.setcorner(x, y) + + release = motion + + def whichxy(self, event): + w = self.cellgrid.winfo_containing(event.x_root, event.y_root) + if w is not None and isinstance(w, Tk.Label): + try: + return w.__x, w.__y + except AttributeError: + pass + return 0, 0 + + def save(self): + self.sheet.save(self.filename) + + def setcurrent(self, x, y): + "Make (x, y) the current cell." + if self.currentxy is not None: + self.change_cell() + self.clearfocus() + self.beacon['text'] = cellname(x, y) + self.load_entry(x, y) + self.entry.focus_set() + self.currentxy = x, y + self.cornerxy = None + gridcell = self.gridcells.get(self.currentxy) + if gridcell is not None: + gridcell['bg'] = 'yellow' + + def setcorner(self, x, y): + if self.currentxy is None or self.currentxy == (x, y): + self.setcurrent(x, y) + return + self.clearfocus() + self.cornerxy = x, y + x1, y1 = self.currentxy + x2, y2 = self.cornerxy or self.currentxy + if x1 > x2: + x1, x2 = x2, x1 + if y1 > y2: + y1, y2 = y2, y1 + for (x, y), cell in self.gridcells.items(): + if x1 <= x <= x2 and y1 <= y <= y2: + cell['bg'] = 'lightBlue' + gridcell = self.gridcells.get(self.currentxy) + if gridcell is not None: + gridcell['bg'] = 'yellow' + self.setbeacon(x1, y1, x2, y2) + + def setbeacon(self, x1, y1, x2, y2): + if x1 == y1 == 1 and x2 == y2 == sys.maxsize: + name = ":" + elif (x1, x2) == (1, sys.maxsize): + if y1 == y2: + name = "%d" % y1 + else: + name = "%d:%d" % (y1, y2) + elif (y1, y2) == (1, sys.maxsize): + if x1 == x2: + name = "%s" % colnum2name(x1) + else: + name = "%s:%s" % (colnum2name(x1), colnum2name(x2)) + else: + name1 = cellname(*self.currentxy) + name2 = cellname(*self.cornerxy) + name = "%s:%s" % (name1, name2) + self.beacon['text'] = name + + + def clearfocus(self): + if self.currentxy is not None: + x1, y1 = self.currentxy + x2, y2 = self.cornerxy or self.currentxy + if x1 > x2: + x1, x2 = x2, x1 + if y1 > y2: + y1, y2 = y2, y1 + for (x, y), cell in self.gridcells.items(): + if x1 <= x <= x2 and y1 <= y <= y2: + cell['bg'] = 'white' + + def return_event(self, event): + "Callback for the Return key." + self.change_cell() + x, y = self.currentxy + self.setcurrent(x, y+1) + return "break" + + def shift_return_event(self, event): + "Callback for the Return key with Shift modifier." + self.change_cell() + x, y = self.currentxy + self.setcurrent(x, max(1, y-1)) + return "break" + + def tab_event(self, event): + "Callback for the Tab key." + self.change_cell() + x, y = self.currentxy + self.setcurrent(x+1, y) + return "break" + + def shift_tab_event(self, event): + "Callback for the Tab key with Shift modifier." + self.change_cell() + x, y = self.currentxy + self.setcurrent(max(1, x-1), y) + return "break" + + def change_cell(self): + "Set the current cell from the entry widget." + x, y = self.currentxy + text = self.entry.get() + cell = None + if text.startswith('='): + cell = FormulaCell(text[1:]) + else: + for cls in int, float, complex: + try: + value = cls(text) + except (TypeError, ValueError): + continue + else: + cell = NumericCell(value) + break + if cell is None and text: + cell = StringCell(text) + if cell is None: + self.sheet.clearcell(x, y) + else: + self.sheet.setcell(x, y, cell) + self.sync() + + def sync(self): + "Fill the GUI cells from the sheet cells." + self.sheet.recalc() + for (x, y), gridcell in self.gridcells.items(): + if x == 0 or y == 0: + continue + cell = self.sheet.getcell(x, y) + if cell is None: + gridcell['text'] = "" + else: + if hasattr(cell, 'format'): + text, alignment = cell.format() + else: + text, alignment = str(cell), LEFT + gridcell['text'] = text + gridcell['anchor'] = align2anchor[alignment] + + +def test_basic(): + "Basic non-gui self-test." + a = Sheet() + for x in range(1, 11): + for y in range(1, 11): + if x == 1: + cell = NumericCell(y) + elif y == 1: + cell = NumericCell(x) + else: + c1 = cellname(x, 1) + c2 = cellname(1, y) + formula = "%s*%s" % (c1, c2) + cell = FormulaCell(formula) + a.setcell(x, y, cell) +## if os.path.isfile("sheet1.xml"): +## print "Loading from sheet1.xml" +## a.load("sheet1.xml") + a.display() + a.save("sheet1.xml") + +def test_gui(): + "GUI test." + if sys.argv[1:]: + filename = sys.argv[1] + else: + filename = "sheet1.xml" + g = SheetGUI(filename) + g.root.mainloop() + +if __name__ == '__main__': + #test_basic() + test_gui() diff --git a/marketing/Tools/demo/vector.py b/marketing/Tools/demo/vector.py new file mode 100644 index 0000000000000000000000000000000000000000..da5b3891d18c62f72824954c8be6ef987ced1015 --- /dev/null +++ b/marketing/Tools/demo/vector.py @@ -0,0 +1,74 @@ +#!/usr/bin/env python3 + +""" +A demonstration of classes and their special methods in Python. +""" + +class Vec: + """A simple vector class. + + Instances of the Vec class can be constructed from numbers + + >>> a = Vec(1, 2, 3) + >>> b = Vec(3, 2, 1) + + added + >>> a + b + Vec(4, 4, 4) + + subtracted + >>> a - b + Vec(-2, 0, 2) + + and multiplied by a scalar on the left + >>> 3.0 * a + Vec(3.0, 6.0, 9.0) + + or on the right + >>> a * 3.0 + Vec(3.0, 6.0, 9.0) + """ + def __init__(self, *v): + self.v = list(v) + + @classmethod + def fromlist(cls, v): + if not isinstance(v, list): + raise TypeError + inst = cls() + inst.v = v + return inst + + def __repr__(self): + args = ', '.join(repr(x) for x in self.v) + return 'Vec({})'.format(args) + + def __len__(self): + return len(self.v) + + def __getitem__(self, i): + return self.v[i] + + def __add__(self, other): + # Element-wise addition + v = [x + y for x, y in zip(self.v, other.v)] + return Vec.fromlist(v) + + def __sub__(self, other): + # Element-wise subtraction + v = [x - y for x, y in zip(self.v, other.v)] + return Vec.fromlist(v) + + def __mul__(self, scalar): + # Multiply by scalar + v = [x * scalar for x in self.v] + return Vec.fromlist(v) + + __rmul__ = __mul__ + + +def test(): + import doctest + doctest.testmod() + +test() diff --git a/marketing/Tools/i18n/__pycache__/makelocalealias.cpython-39.pyc b/marketing/Tools/i18n/__pycache__/makelocalealias.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8160d2b2bb84ca02d86b692b2b6e7a41555c91df Binary files /dev/null and b/marketing/Tools/i18n/__pycache__/makelocalealias.cpython-39.pyc differ diff --git a/marketing/Tools/i18n/__pycache__/msgfmt.cpython-39.pyc b/marketing/Tools/i18n/__pycache__/msgfmt.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00975110d24f539cbc4f7bfbce5d1a3f4351444c Binary files /dev/null and b/marketing/Tools/i18n/__pycache__/msgfmt.cpython-39.pyc differ diff --git a/marketing/Tools/i18n/__pycache__/pygettext.cpython-39.pyc b/marketing/Tools/i18n/__pycache__/pygettext.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..427c0a573b45ebc5a1b7b3728abd3563b2804055 Binary files /dev/null and b/marketing/Tools/i18n/__pycache__/pygettext.cpython-39.pyc differ diff --git a/marketing/Tools/i18n/makelocalealias.py b/marketing/Tools/i18n/makelocalealias.py new file mode 100644 index 0000000000000000000000000000000000000000..b407a8a643be7c047d93c21405cb7ae0295ca10f --- /dev/null +++ b/marketing/Tools/i18n/makelocalealias.py @@ -0,0 +1,153 @@ +#!/usr/bin/env python3 +""" + Convert the X11 locale.alias file into a mapping dictionary suitable + for locale.py. + + Written by Marc-Andre Lemburg , 2004-12-10. + +""" +import locale +import sys +_locale = locale + +# Location of the X11 alias file. +LOCALE_ALIAS = '/usr/share/X11/locale/locale.alias' +# Location of the glibc SUPPORTED locales file. +SUPPORTED = '/usr/share/i18n/SUPPORTED' + +def parse(filename): + + with open(filename, encoding='latin1') as f: + lines = list(f) + # Remove mojibake in /usr/share/X11/locale/locale.alias. + # b'\xef\xbf\xbd' == '\ufffd'.encode('utf-8') + lines = [line for line in lines if '\xef\xbf\xbd' not in line] + data = {} + for line in lines: + line = line.strip() + if not line: + continue + if line[:1] == '#': + continue + locale, alias = line.split() + # Fix non-standard locale names, e.g. ks_IN@devanagari.UTF-8 + if '@' in alias: + alias_lang, _, alias_mod = alias.partition('@') + if '.' in alias_mod: + alias_mod, _, alias_enc = alias_mod.partition('.') + alias = alias_lang + '.' + alias_enc + '@' + alias_mod + # Strip ':' + if locale[-1] == ':': + locale = locale[:-1] + # Lower-case locale + locale = locale.lower() + # Ignore one letter locale mappings (except for 'c') + if len(locale) == 1 and locale != 'c': + continue + # Normalize encoding, if given + if '.' in locale: + lang, encoding = locale.split('.')[:2] + encoding = encoding.replace('-', '') + encoding = encoding.replace('_', '') + locale = lang + '.' + encoding + data[locale] = alias + return data + +def parse_glibc_supported(filename): + + with open(filename, encoding='latin1') as f: + lines = list(f) + data = {} + for line in lines: + line = line.strip() + if not line: + continue + if line[:1] == '#': + continue + line = line.replace('/', ' ').strip() + line = line.rstrip('\\').rstrip() + words = line.split() + if len(words) != 2: + continue + alias, alias_encoding = words + # Lower-case locale + locale = alias.lower() + # Normalize encoding, if given + if '.' in locale: + lang, encoding = locale.split('.')[:2] + encoding = encoding.replace('-', '') + encoding = encoding.replace('_', '') + locale = lang + '.' + encoding + # Add an encoding to alias + alias, _, modifier = alias.partition('@') + alias = _locale._replace_encoding(alias, alias_encoding) + if modifier and not (modifier == 'euro' and alias_encoding == 'ISO-8859-15'): + alias += '@' + modifier + data[locale] = alias + return data + +def pprint(data): + items = sorted(data.items()) + for k, v in items: + print(' %-40s%a,' % ('%a:' % k, v)) + +def print_differences(data, olddata): + items = sorted(olddata.items()) + for k, v in items: + if k not in data: + print('# removed %a' % k) + elif olddata[k] != data[k]: + print('# updated %a -> %a to %a' % \ + (k, olddata[k], data[k])) + # Additions are not mentioned + +def optimize(data): + locale_alias = locale.locale_alias + locale.locale_alias = data.copy() + for k, v in data.items(): + del locale.locale_alias[k] + if locale.normalize(k) != v: + locale.locale_alias[k] = v + newdata = locale.locale_alias + errors = check(data) + locale.locale_alias = locale_alias + if errors: + sys.exit(1) + return newdata + +def check(data): + # Check that all alias definitions from the X11 file + # are actually mapped to the correct alias locales. + errors = 0 + for k, v in data.items(): + if locale.normalize(k) != v: + print('ERROR: %a -> %a != %a' % (k, locale.normalize(k), v), + file=sys.stderr) + errors += 1 + return errors + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser() + parser.add_argument('--locale-alias', default=LOCALE_ALIAS, + help='location of the X11 alias file ' + '(default: %a)' % LOCALE_ALIAS) + parser.add_argument('--glibc-supported', default=SUPPORTED, + help='location of the glibc SUPPORTED locales file ' + '(default: %a)' % SUPPORTED) + args = parser.parse_args() + + data = locale.locale_alias.copy() + data.update(parse_glibc_supported(args.glibc_supported)) + data.update(parse(args.locale_alias)) + while True: + # Repeat optimization while the size is decreased. + n = len(data) + data = optimize(data) + if len(data) == n: + break + print_differences(data, locale.locale_alias) + print() + print('locale_alias = {') + pprint(data) + print('}') diff --git a/marketing/Tools/i18n/msgfmt.py b/marketing/Tools/i18n/msgfmt.py new file mode 100644 index 0000000000000000000000000000000000000000..3f731e941eafe77418e9e8c451a52170ee2bc8fa --- /dev/null +++ b/marketing/Tools/i18n/msgfmt.py @@ -0,0 +1,246 @@ +#! /usr/bin/env python3 +# Written by Martin v. Löwis + +"""Generate binary message catalog from textual translation description. + +This program converts a textual Uniforum-style message catalog (.po file) into +a binary GNU catalog (.mo file). This is essentially the same function as the +GNU msgfmt program, however, it is a simpler implementation. Currently it +does not handle plural forms but it does handle message contexts. + +Usage: msgfmt.py [OPTIONS] filename.po + +Options: + -o file + --output-file=file + Specify the output file to write to. If omitted, output will go to a + file named filename.mo (based off the input file name). + + -h + --help + Print this message and exit. + + -V + --version + Display version information and exit. +""" + +import os +import sys +import ast +import getopt +import struct +import array +from email.parser import HeaderParser + +__version__ = "1.2" + +MESSAGES = {} + + +def usage(code, msg=''): + print(__doc__, file=sys.stderr) + if msg: + print(msg, file=sys.stderr) + sys.exit(code) + + +def add(ctxt, id, str, fuzzy): + "Add a non-fuzzy translation to the dictionary." + global MESSAGES + if not fuzzy and str: + if ctxt is None: + MESSAGES[id] = str + else: + MESSAGES[b"%b\x04%b" % (ctxt, id)] = str + + +def generate(): + "Return the generated output." + global MESSAGES + # the keys are sorted in the .mo file + keys = sorted(MESSAGES.keys()) + offsets = [] + ids = strs = b'' + for id in keys: + # For each string, we need size and file offset. Each string is NUL + # terminated; the NUL does not count into the size. + offsets.append((len(ids), len(id), len(strs), len(MESSAGES[id]))) + ids += id + b'\0' + strs += MESSAGES[id] + b'\0' + output = '' + # The header is 7 32-bit unsigned integers. We don't use hash tables, so + # the keys start right after the index tables. + # translated string. + keystart = 7*4+16*len(keys) + # and the values start after the keys + valuestart = keystart + len(ids) + koffsets = [] + voffsets = [] + # The string table first has the list of keys, then the list of values. + # Each entry has first the size of the string, then the file offset. + for o1, l1, o2, l2 in offsets: + koffsets += [l1, o1+keystart] + voffsets += [l2, o2+valuestart] + offsets = koffsets + voffsets + output = struct.pack("Iiiiiii", + 0x950412de, # Magic + 0, # Version + len(keys), # # of entries + 7*4, # start of key index + 7*4+len(keys)*8, # start of value index + 0, 0) # size and offset of hash table + output += array.array("i", offsets).tobytes() + output += ids + output += strs + return output + + +def make(filename, outfile): + ID = 1 + STR = 2 + CTXT = 3 + + # Compute .mo name from .po name and arguments + if filename.endswith('.po'): + infile = filename + else: + infile = filename + '.po' + if outfile is None: + outfile = os.path.splitext(infile)[0] + '.mo' + + try: + with open(infile, 'rb') as f: + lines = f.readlines() + except IOError as msg: + print(msg, file=sys.stderr) + sys.exit(1) + + section = msgctxt = None + fuzzy = 0 + + # Start off assuming Latin-1, so everything decodes without failure, + # until we know the exact encoding + encoding = 'latin-1' + + # Parse the catalog + lno = 0 + for l in lines: + l = l.decode(encoding) + lno += 1 + # If we get a comment line after a msgstr, this is a new entry + if l[0] == '#' and section == STR: + add(msgctxt, msgid, msgstr, fuzzy) + section = msgctxt = None + fuzzy = 0 + # Record a fuzzy mark + if l[:2] == '#,' and 'fuzzy' in l: + fuzzy = 1 + # Skip comments + if l[0] == '#': + continue + # Now we are in a msgid or msgctxt section, output previous section + if l.startswith('msgctxt'): + if section == STR: + add(msgctxt, msgid, msgstr, fuzzy) + section = CTXT + l = l[7:] + msgctxt = b'' + elif l.startswith('msgid') and not l.startswith('msgid_plural'): + if section == STR: + add(msgctxt, msgid, msgstr, fuzzy) + if not msgid: + # See whether there is an encoding declaration + p = HeaderParser() + charset = p.parsestr(msgstr.decode(encoding)).get_content_charset() + if charset: + encoding = charset + section = ID + l = l[5:] + msgid = msgstr = b'' + is_plural = False + # This is a message with plural forms + elif l.startswith('msgid_plural'): + if section != ID: + print('msgid_plural not preceded by msgid on %s:%d' % (infile, lno), + file=sys.stderr) + sys.exit(1) + l = l[12:] + msgid += b'\0' # separator of singular and plural + is_plural = True + # Now we are in a msgstr section + elif l.startswith('msgstr'): + section = STR + if l.startswith('msgstr['): + if not is_plural: + print('plural without msgid_plural on %s:%d' % (infile, lno), + file=sys.stderr) + sys.exit(1) + l = l.split(']', 1)[1] + if msgstr: + msgstr += b'\0' # Separator of the various plural forms + else: + if is_plural: + print('indexed msgstr required for plural on %s:%d' % (infile, lno), + file=sys.stderr) + sys.exit(1) + l = l[6:] + # Skip empty lines + l = l.strip() + if not l: + continue + l = ast.literal_eval(l) + if section == CTXT: + msgctxt += l.encode(encoding) + elif section == ID: + msgid += l.encode(encoding) + elif section == STR: + msgstr += l.encode(encoding) + else: + print('Syntax error on %s:%d' % (infile, lno), \ + 'before:', file=sys.stderr) + print(l, file=sys.stderr) + sys.exit(1) + # Add last entry + if section == STR: + add(msgctxt, msgid, msgstr, fuzzy) + + # Compute output + output = generate() + + try: + with open(outfile,"wb") as f: + f.write(output) + except IOError as msg: + print(msg, file=sys.stderr) + + +def main(): + try: + opts, args = getopt.getopt(sys.argv[1:], 'hVo:', + ['help', 'version', 'output-file=']) + except getopt.error as msg: + usage(1, msg) + + outfile = None + # parse options + for opt, arg in opts: + if opt in ('-h', '--help'): + usage(0) + elif opt in ('-V', '--version'): + print("msgfmt.py", __version__) + sys.exit(0) + elif opt in ('-o', '--output-file'): + outfile = arg + # do it + if not args: + print('No input file given', file=sys.stderr) + print("Try `msgfmt --help' for more information.", file=sys.stderr) + return + + for filename in args: + make(filename, outfile) + + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/i18n/pygettext.py b/marketing/Tools/i18n/pygettext.py new file mode 100644 index 0000000000000000000000000000000000000000..b29b0d8e12d24dec6b637b689372fee4c2b1e05c --- /dev/null +++ b/marketing/Tools/i18n/pygettext.py @@ -0,0 +1,630 @@ +#! /usr/bin/env python3 +# -*- coding: iso-8859-1 -*- +# Originally written by Barry Warsaw +# +# Minimally patched to make it even more xgettext compatible +# by Peter Funk +# +# 2002-11-22 Jrgen Hermann +# Added checks that _() only contains string literals, and +# command line args are resolved to module lists, i.e. you +# can now pass a filename, a module or package name, or a +# directory (including globbing chars, important for Win32). +# Made docstring fit in 80 chars wide displays using pydoc. +# + +# for selftesting +try: + import fintl + _ = fintl.gettext +except ImportError: + _ = lambda s: s + +__doc__ = _("""pygettext -- Python equivalent of xgettext(1) + +Many systems (Solaris, Linux, Gnu) provide extensive tools that ease the +internationalization of C programs. Most of these tools are independent of +the programming language and can be used from within Python programs. +Martin von Loewis' work[1] helps considerably in this regard. + +There's one problem though; xgettext is the program that scans source code +looking for message strings, but it groks only C (or C++). Python +introduces a few wrinkles, such as dual quoting characters, triple quoted +strings, and raw strings. xgettext understands none of this. + +Enter pygettext, which uses Python's standard tokenize module to scan +Python source code, generating .pot files identical to what GNU xgettext[2] +generates for C and C++ code. From there, the standard GNU tools can be +used. + +A word about marking Python strings as candidates for translation. GNU +xgettext recognizes the following keywords: gettext, dgettext, dcgettext, +and gettext_noop. But those can be a lot of text to include all over your +code. C and C++ have a trick: they use the C preprocessor. Most +internationalized C source includes a #define for gettext() to _() so that +what has to be written in the source is much less. Thus these are both +translatable strings: + + gettext("Translatable String") + _("Translatable String") + +Python of course has no preprocessor so this doesn't work so well. Thus, +pygettext searches only for _() by default, but see the -k/--keyword flag +below for how to augment this. + + [1] https://www.python.org/workshops/1997-10/proceedings/loewis.html + [2] https://www.gnu.org/software/gettext/gettext.html + +NOTE: pygettext attempts to be option and feature compatible with GNU +xgettext where ever possible. However some options are still missing or are +not fully implemented. Also, xgettext's use of command line switches with +option arguments is broken, and in these cases, pygettext just defines +additional switches. + +Usage: pygettext [options] inputfile ... + +Options: + + -a + --extract-all + Extract all strings. + + -d name + --default-domain=name + Rename the default output file from messages.pot to name.pot. + + -E + --escape + Replace non-ASCII characters with octal escape sequences. + + -D + --docstrings + Extract module, class, method, and function docstrings. These do + not need to be wrapped in _() markers, and in fact cannot be for + Python to consider them docstrings. (See also the -X option). + + -h + --help + Print this help message and exit. + + -k word + --keyword=word + Keywords to look for in addition to the default set, which are: + %(DEFAULTKEYWORDS)s + + You can have multiple -k flags on the command line. + + -K + --no-default-keywords + Disable the default set of keywords (see above). Any keywords + explicitly added with the -k/--keyword option are still recognized. + + --no-location + Do not write filename/lineno location comments. + + -n + --add-location + Write filename/lineno location comments indicating where each + extracted string is found in the source. These lines appear before + each msgid. The style of comments is controlled by the -S/--style + option. This is the default. + + -o filename + --output=filename + Rename the default output file from messages.pot to filename. If + filename is `-' then the output is sent to standard out. + + -p dir + --output-dir=dir + Output files will be placed in directory dir. + + -S stylename + --style stylename + Specify which style to use for location comments. Two styles are + supported: + + Solaris # File: filename, line: line-number + GNU #: filename:line + + The style name is case insensitive. GNU style is the default. + + -v + --verbose + Print the names of the files being processed. + + -V + --version + Print the version of pygettext and exit. + + -w columns + --width=columns + Set width of output to columns. + + -x filename + --exclude-file=filename + Specify a file that contains a list of strings that are not be + extracted from the input files. Each string to be excluded must + appear on a line by itself in the file. + + -X filename + --no-docstrings=filename + Specify a file that contains a list of files (one per line) that + should not have their docstrings extracted. This is only useful in + conjunction with the -D option above. + +If `inputfile' is -, standard input is read. +""") + +import os +import importlib.machinery +import importlib.util +import sys +import glob +import time +import getopt +import token +import tokenize + +__version__ = '1.5' + +default_keywords = ['_'] +DEFAULTKEYWORDS = ', '.join(default_keywords) + +EMPTYSTRING = '' + + + +# The normal pot-file header. msgmerge and Emacs's po-mode work better if it's +# there. +pot_header = _('''\ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) YEAR ORGANIZATION +# FIRST AUTHOR , YEAR. +# +msgid "" +msgstr "" +"Project-Id-Version: PACKAGE VERSION\\n" +"POT-Creation-Date: %(time)s\\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n" +"Last-Translator: FULL NAME \\n" +"Language-Team: LANGUAGE \\n" +"MIME-Version: 1.0\\n" +"Content-Type: text/plain; charset=%(charset)s\\n" +"Content-Transfer-Encoding: %(encoding)s\\n" +"Generated-By: pygettext.py %(version)s\\n" + +''') + + +def usage(code, msg=''): + print(__doc__ % globals(), file=sys.stderr) + if msg: + print(msg, file=sys.stderr) + sys.exit(code) + + + +def make_escapes(pass_nonascii): + global escapes, escape + if pass_nonascii: + # Allow non-ascii characters to pass through so that e.g. 'msgid + # "Hhe"' would result not result in 'msgid "H\366he"'. Otherwise we + # escape any character outside the 32..126 range. + mod = 128 + escape = escape_ascii + else: + mod = 256 + escape = escape_nonascii + escapes = [r"\%03o" % i for i in range(mod)] + for i in range(32, 127): + escapes[i] = chr(i) + escapes[ord('\\')] = r'\\' + escapes[ord('\t')] = r'\t' + escapes[ord('\r')] = r'\r' + escapes[ord('\n')] = r'\n' + escapes[ord('\"')] = r'\"' + + +def escape_ascii(s, encoding): + return ''.join(escapes[ord(c)] if ord(c) < 128 else c for c in s) + +def escape_nonascii(s, encoding): + return ''.join(escapes[b] for b in s.encode(encoding)) + + +def is_literal_string(s): + return s[0] in '\'"' or (s[0] in 'rRuU' and s[1] in '\'"') + + +def safe_eval(s): + # unwrap quotes, safely + return eval(s, {'__builtins__':{}}, {}) + + +def normalize(s, encoding): + # This converts the various Python string types into a format that is + # appropriate for .po files, namely much closer to C style. + lines = s.split('\n') + if len(lines) == 1: + s = '"' + escape(s, encoding) + '"' + else: + if not lines[-1]: + del lines[-1] + lines[-1] = lines[-1] + '\n' + for i in range(len(lines)): + lines[i] = escape(lines[i], encoding) + lineterm = '\\n"\n"' + s = '""\n"' + lineterm.join(lines) + '"' + return s + + +def containsAny(str, set): + """Check whether 'str' contains ANY of the chars in 'set'""" + return 1 in [c in str for c in set] + + +def getFilesForName(name): + """Get a list of module files for a filename, a module or package name, + or a directory. + """ + if not os.path.exists(name): + # check for glob chars + if containsAny(name, "*?[]"): + files = glob.glob(name) + list = [] + for file in files: + list.extend(getFilesForName(file)) + return list + + # try to find module or package + try: + spec = importlib.util.find_spec(name) + name = spec.origin + except ImportError: + name = None + if not name: + return [] + + if os.path.isdir(name): + # find all python files in directory + list = [] + # get extension for python source files + _py_ext = importlib.machinery.SOURCE_SUFFIXES[0] + for root, dirs, files in os.walk(name): + # don't recurse into CVS directories + if 'CVS' in dirs: + dirs.remove('CVS') + # add all *.py files to list + list.extend( + [os.path.join(root, file) for file in files + if os.path.splitext(file)[1] == _py_ext] + ) + return list + elif os.path.exists(name): + # a single file + return [name] + + return [] + + +class TokenEater: + def __init__(self, options): + self.__options = options + self.__messages = {} + self.__state = self.__waiting + self.__data = [] + self.__lineno = -1 + self.__freshmodule = 1 + self.__curfile = None + self.__enclosurecount = 0 + + def __call__(self, ttype, tstring, stup, etup, line): + # dispatch +## import token +## print('ttype:', token.tok_name[ttype], 'tstring:', tstring, +## file=sys.stderr) + self.__state(ttype, tstring, stup[0]) + + def __waiting(self, ttype, tstring, lineno): + opts = self.__options + # Do docstring extractions, if enabled + if opts.docstrings and not opts.nodocstrings.get(self.__curfile): + # module docstring? + if self.__freshmodule: + if ttype == tokenize.STRING and is_literal_string(tstring): + self.__addentry(safe_eval(tstring), lineno, isdocstring=1) + self.__freshmodule = 0 + elif ttype not in (tokenize.COMMENT, tokenize.NL): + self.__freshmodule = 0 + return + # class or func/method docstring? + if ttype == tokenize.NAME and tstring in ('class', 'def'): + self.__state = self.__suiteseen + return + if ttype == tokenize.NAME and tstring in opts.keywords: + self.__state = self.__keywordseen + + def __suiteseen(self, ttype, tstring, lineno): + # skip over any enclosure pairs until we see the colon + if ttype == tokenize.OP: + if tstring == ':' and self.__enclosurecount == 0: + # we see a colon and we're not in an enclosure: end of def + self.__state = self.__suitedocstring + elif tstring in '([{': + self.__enclosurecount += 1 + elif tstring in ')]}': + self.__enclosurecount -= 1 + + def __suitedocstring(self, ttype, tstring, lineno): + # ignore any intervening noise + if ttype == tokenize.STRING and is_literal_string(tstring): + self.__addentry(safe_eval(tstring), lineno, isdocstring=1) + self.__state = self.__waiting + elif ttype not in (tokenize.NEWLINE, tokenize.INDENT, + tokenize.COMMENT): + # there was no class docstring + self.__state = self.__waiting + + def __keywordseen(self, ttype, tstring, lineno): + if ttype == tokenize.OP and tstring == '(': + self.__data = [] + self.__lineno = lineno + self.__state = self.__openseen + else: + self.__state = self.__waiting + + def __openseen(self, ttype, tstring, lineno): + if ttype == tokenize.OP and tstring == ')': + # We've seen the last of the translatable strings. Record the + # line number of the first line of the strings and update the list + # of messages seen. Reset state for the next batch. If there + # were no strings inside _(), then just ignore this entry. + if self.__data: + self.__addentry(EMPTYSTRING.join(self.__data)) + self.__state = self.__waiting + elif ttype == tokenize.STRING and is_literal_string(tstring): + self.__data.append(safe_eval(tstring)) + elif ttype not in [tokenize.COMMENT, token.INDENT, token.DEDENT, + token.NEWLINE, tokenize.NL]: + # warn if we see anything else than STRING or whitespace + print(_( + '*** %(file)s:%(lineno)s: Seen unexpected token "%(token)s"' + ) % { + 'token': tstring, + 'file': self.__curfile, + 'lineno': self.__lineno + }, file=sys.stderr) + self.__state = self.__waiting + + def __addentry(self, msg, lineno=None, isdocstring=0): + if lineno is None: + lineno = self.__lineno + if not msg in self.__options.toexclude: + entry = (self.__curfile, lineno) + self.__messages.setdefault(msg, {})[entry] = isdocstring + + def set_filename(self, filename): + self.__curfile = filename + self.__freshmodule = 1 + + def write(self, fp): + options = self.__options + timestamp = time.strftime('%Y-%m-%d %H:%M%z') + encoding = fp.encoding if fp.encoding else 'UTF-8' + print(pot_header % {'time': timestamp, 'version': __version__, + 'charset': encoding, + 'encoding': '8bit'}, file=fp) + # Sort the entries. First sort each particular entry's keys, then + # sort all the entries by their first item. + reverse = {} + for k, v in self.__messages.items(): + keys = sorted(v.keys()) + reverse.setdefault(tuple(keys), []).append((k, v)) + rkeys = sorted(reverse.keys()) + for rkey in rkeys: + rentries = reverse[rkey] + rentries.sort() + for k, v in rentries: + # If the entry was gleaned out of a docstring, then add a + # comment stating so. This is to aid translators who may wish + # to skip translating some unimportant docstrings. + isdocstring = any(v.values()) + # k is the message string, v is a dictionary-set of (filename, + # lineno) tuples. We want to sort the entries in v first by + # file name and then by line number. + v = sorted(v.keys()) + if not options.writelocations: + pass + # location comments are different b/w Solaris and GNU: + elif options.locationstyle == options.SOLARIS: + for filename, lineno in v: + d = {'filename': filename, 'lineno': lineno} + print(_( + '# File: %(filename)s, line: %(lineno)d') % d, file=fp) + elif options.locationstyle == options.GNU: + # fit as many locations on one line, as long as the + # resulting line length doesn't exceed 'options.width' + locline = '#:' + for filename, lineno in v: + d = {'filename': filename, 'lineno': lineno} + s = _(' %(filename)s:%(lineno)d') % d + if len(locline) + len(s) <= options.width: + locline = locline + s + else: + print(locline, file=fp) + locline = "#:" + s + if len(locline) > 2: + print(locline, file=fp) + if isdocstring: + print('#, docstring', file=fp) + print('msgid', normalize(k, encoding), file=fp) + print('msgstr ""\n', file=fp) + + + +def main(): + global default_keywords + try: + opts, args = getopt.getopt( + sys.argv[1:], + 'ad:DEhk:Kno:p:S:Vvw:x:X:', + ['extract-all', 'default-domain=', 'escape', 'help', + 'keyword=', 'no-default-keywords', + 'add-location', 'no-location', 'output=', 'output-dir=', + 'style=', 'verbose', 'version', 'width=', 'exclude-file=', + 'docstrings', 'no-docstrings', + ]) + except getopt.error as msg: + usage(1, msg) + + # for holding option values + class Options: + # constants + GNU = 1 + SOLARIS = 2 + # defaults + extractall = 0 # FIXME: currently this option has no effect at all. + escape = 0 + keywords = [] + outpath = '' + outfile = 'messages.pot' + writelocations = 1 + locationstyle = GNU + verbose = 0 + width = 78 + excludefilename = '' + docstrings = 0 + nodocstrings = {} + + options = Options() + locations = {'gnu' : options.GNU, + 'solaris' : options.SOLARIS, + } + + # parse options + for opt, arg in opts: + if opt in ('-h', '--help'): + usage(0) + elif opt in ('-a', '--extract-all'): + options.extractall = 1 + elif opt in ('-d', '--default-domain'): + options.outfile = arg + '.pot' + elif opt in ('-E', '--escape'): + options.escape = 1 + elif opt in ('-D', '--docstrings'): + options.docstrings = 1 + elif opt in ('-k', '--keyword'): + options.keywords.append(arg) + elif opt in ('-K', '--no-default-keywords'): + default_keywords = [] + elif opt in ('-n', '--add-location'): + options.writelocations = 1 + elif opt in ('--no-location',): + options.writelocations = 0 + elif opt in ('-S', '--style'): + options.locationstyle = locations.get(arg.lower()) + if options.locationstyle is None: + usage(1, _('Invalid value for --style: %s') % arg) + elif opt in ('-o', '--output'): + options.outfile = arg + elif opt in ('-p', '--output-dir'): + options.outpath = arg + elif opt in ('-v', '--verbose'): + options.verbose = 1 + elif opt in ('-V', '--version'): + print(_('pygettext.py (xgettext for Python) %s') % __version__) + sys.exit(0) + elif opt in ('-w', '--width'): + try: + options.width = int(arg) + except ValueError: + usage(1, _('--width argument must be an integer: %s') % arg) + elif opt in ('-x', '--exclude-file'): + options.excludefilename = arg + elif opt in ('-X', '--no-docstrings'): + fp = open(arg) + try: + while 1: + line = fp.readline() + if not line: + break + options.nodocstrings[line[:-1]] = 1 + finally: + fp.close() + + # calculate escapes + make_escapes(not options.escape) + + # calculate all keywords + options.keywords.extend(default_keywords) + + # initialize list of strings to exclude + if options.excludefilename: + try: + with open(options.excludefilename) as fp: + options.toexclude = fp.readlines() + except IOError: + print(_( + "Can't read --exclude-file: %s") % options.excludefilename, file=sys.stderr) + sys.exit(1) + else: + options.toexclude = [] + + # resolve args to module lists + expanded = [] + for arg in args: + if arg == '-': + expanded.append(arg) + else: + expanded.extend(getFilesForName(arg)) + args = expanded + + # slurp through all the files + eater = TokenEater(options) + for filename in args: + if filename == '-': + if options.verbose: + print(_('Reading standard input')) + fp = sys.stdin.buffer + closep = 0 + else: + if options.verbose: + print(_('Working on %s') % filename) + fp = open(filename, 'rb') + closep = 1 + try: + eater.set_filename(filename) + try: + tokens = tokenize.tokenize(fp.readline) + for _token in tokens: + eater(*_token) + except tokenize.TokenError as e: + print('%s: %s, line %d, column %d' % ( + e.args[0], filename, e.args[1][0], e.args[1][1]), + file=sys.stderr) + finally: + if closep: + fp.close() + + # write the output + if options.outfile == '-': + fp = sys.stdout + closep = 0 + else: + if options.outpath: + options.outfile = os.path.join(options.outpath, options.outfile) + fp = open(options.outfile, 'w') + closep = 1 + try: + eater.write(fp) + finally: + if closep: + fp.close() + + +if __name__ == '__main__': + main() + # some more test strings + # this one creates a warning + _('*** Seen unexpected token "%(token)s"') % {'token': 'test'} + _('more' 'than' 'one' 'string') diff --git a/marketing/Tools/pynche/ChipViewer.py b/marketing/Tools/pynche/ChipViewer.py new file mode 100644 index 0000000000000000000000000000000000000000..78139f8f2da9502b29f4381f49332eab9cc45506 --- /dev/null +++ b/marketing/Tools/pynche/ChipViewer.py @@ -0,0 +1,130 @@ +"""Chip viewer and widget. + +In the lower left corner of the main Pynche window, you will see two +ChipWidgets, one for the selected color and one for the nearest color. The +selected color is the actual RGB value expressed as an X11 #COLOR name. The +nearest color is the named color from the X11 database that is closest to the +selected color in 3D space. There may be other colors equally close, but the +nearest one is the first one found. + +Clicking on the nearest color chip selects that named color. + +The ChipViewer class includes the entire lower left quandrant; i.e. both the +selected and nearest ChipWidgets. +""" + +from tkinter import * +import ColorDB + + +class ChipWidget: + _WIDTH = 150 + _HEIGHT = 80 + + def __init__(self, + master = None, + width = _WIDTH, + height = _HEIGHT, + text = 'Color', + initialcolor = 'blue', + presscmd = None, + releasecmd = None): + # create the text label + self.__label = Label(master, text=text) + self.__label.grid(row=0, column=0) + # create the color chip, implemented as a frame + self.__chip = Frame(master, relief=RAISED, borderwidth=2, + width=width, + height=height, + background=initialcolor) + self.__chip.grid(row=1, column=0) + # create the color name + self.__namevar = StringVar() + self.__namevar.set(initialcolor) + self.__name = Entry(master, textvariable=self.__namevar, + relief=FLAT, justify=CENTER, state=DISABLED, + font=self.__label['font']) + self.__name.grid(row=2, column=0) + # create the message area + self.__msgvar = StringVar() + self.__name = Entry(master, textvariable=self.__msgvar, + relief=FLAT, justify=CENTER, state=DISABLED, + font=self.__label['font']) + self.__name.grid(row=3, column=0) + # set bindings + if presscmd: + self.__chip.bind('', presscmd) + if releasecmd: + self.__chip.bind('', releasecmd) + + def set_color(self, color): + self.__chip.config(background=color) + + def get_color(self): + return self.__chip['background'] + + def set_name(self, colorname): + self.__namevar.set(colorname) + + def set_message(self, message): + self.__msgvar.set(message) + + def press(self): + self.__chip.configure(relief=SUNKEN) + + def release(self): + self.__chip.configure(relief=RAISED) + + + +class ChipViewer: + def __init__(self, switchboard, master=None): + self.__sb = switchboard + self.__frame = Frame(master, relief=RAISED, borderwidth=1) + self.__frame.grid(row=3, column=0, ipadx=5, sticky='NSEW') + # create the chip that will display the currently selected color + # exactly + self.__sframe = Frame(self.__frame) + self.__sframe.grid(row=0, column=0) + self.__selected = ChipWidget(self.__sframe, text='Selected') + # create the chip that will display the nearest real X11 color + # database color name + self.__nframe = Frame(self.__frame) + self.__nframe.grid(row=0, column=1) + self.__nearest = ChipWidget(self.__nframe, text='Nearest', + presscmd = self.__buttonpress, + releasecmd = self.__buttonrelease) + + def update_yourself(self, red, green, blue): + # Selected always shows the #rrggbb name of the color, nearest always + # shows the name of the nearest color in the database. BAW: should + # an exact match be indicated in some way? + # + # Always use the #rrggbb style to actually set the color, since we may + # not be using X color names (e.g. "web-safe" names) + colordb = self.__sb.colordb() + rgbtuple = (red, green, blue) + rrggbb = ColorDB.triplet_to_rrggbb(rgbtuple) + # find the nearest + nearest = colordb.nearest(red, green, blue) + nearest_tuple = colordb.find_byname(nearest) + nearest_rrggbb = ColorDB.triplet_to_rrggbb(nearest_tuple) + self.__selected.set_color(rrggbb) + self.__nearest.set_color(nearest_rrggbb) + # set the name and messages areas + self.__selected.set_name(rrggbb) + if rrggbb == nearest_rrggbb: + self.__selected.set_message(nearest) + else: + self.__selected.set_message('') + self.__nearest.set_name(nearest_rrggbb) + self.__nearest.set_message(nearest) + + def __buttonpress(self, event=None): + self.__nearest.press() + + def __buttonrelease(self, event=None): + self.__nearest.release() + rrggbb = self.__nearest.get_color() + red, green, blue = ColorDB.rrggbb_to_triplet(rrggbb) + self.__sb.update_views(red, green, blue) diff --git a/marketing/Tools/pynche/ColorDB.py b/marketing/Tools/pynche/ColorDB.py new file mode 100644 index 0000000000000000000000000000000000000000..c013a60896908963c279f3a36e1e94d7b42fcacf --- /dev/null +++ b/marketing/Tools/pynche/ColorDB.py @@ -0,0 +1,271 @@ +"""Color Database. + +This file contains one class, called ColorDB, and several utility functions. +The class must be instantiated by the get_colordb() function in this file, +passing it a filename to read a database out of. + +The get_colordb() function will try to examine the file to figure out what the +format of the file is. If it can't figure out the file format, or it has +trouble reading the file, None is returned. You can pass get_colordb() an +optional filetype argument. + +Supported file types are: + + X_RGB_TXT -- X Consortium rgb.txt format files. Three columns of numbers + from 0 .. 255 separated by whitespace. Arbitrary trailing + columns used as the color name. + +The utility functions are useful for converting between the various expected +color formats, and for calculating other color values. + +""" + +import sys +import re +from types import * + +class BadColor(Exception): + pass + +DEFAULT_DB = None +SPACE = ' ' +COMMASPACE = ', ' + + + +# generic class +class ColorDB: + def __init__(self, fp): + lineno = 2 + self.__name = fp.name + # Maintain several dictionaries for indexing into the color database. + # Note that while Tk supports RGB intensities of 4, 8, 12, or 16 bits, + # for now we only support 8 bit intensities. At least on OpenWindows, + # all intensities in the /usr/openwin/lib/rgb.txt file are 8-bit + # + # key is (red, green, blue) tuple, value is (name, [aliases]) + self.__byrgb = {} + # key is name, value is (red, green, blue) + self.__byname = {} + # all unique names (non-aliases). built-on demand + self.__allnames = None + for line in fp: + # get this compiled regular expression from derived class + mo = self._re.match(line) + if not mo: + print('Error in', fp.name, ' line', lineno, file=sys.stderr) + lineno += 1 + continue + # extract the red, green, blue, and name + red, green, blue = self._extractrgb(mo) + name = self._extractname(mo) + keyname = name.lower() + # BAW: for now the `name' is just the first named color with the + # rgb values we find. Later, we might want to make the two word + # version the `name', or the CapitalizedVersion, etc. + key = (red, green, blue) + foundname, aliases = self.__byrgb.get(key, (name, [])) + if foundname != name and foundname not in aliases: + aliases.append(name) + self.__byrgb[key] = (foundname, aliases) + # add to byname lookup + self.__byname[keyname] = key + lineno = lineno + 1 + + # override in derived classes + def _extractrgb(self, mo): + return [int(x) for x in mo.group('red', 'green', 'blue')] + + def _extractname(self, mo): + return mo.group('name') + + def filename(self): + return self.__name + + def find_byrgb(self, rgbtuple): + """Return name for rgbtuple""" + try: + return self.__byrgb[rgbtuple] + except KeyError: + raise BadColor(rgbtuple) from None + + def find_byname(self, name): + """Return (red, green, blue) for name""" + name = name.lower() + try: + return self.__byname[name] + except KeyError: + raise BadColor(name) from None + + def nearest(self, red, green, blue): + """Return the name of color nearest (red, green, blue)""" + # BAW: should we use Voronoi diagrams, Delaunay triangulation, or + # octree for speeding up the locating of nearest point? Exhaustive + # search is inefficient, but seems fast enough. + nearest = -1 + nearest_name = '' + for name, aliases in self.__byrgb.values(): + r, g, b = self.__byname[name.lower()] + rdelta = red - r + gdelta = green - g + bdelta = blue - b + distance = rdelta * rdelta + gdelta * gdelta + bdelta * bdelta + if nearest == -1 or distance < nearest: + nearest = distance + nearest_name = name + return nearest_name + + def unique_names(self): + # sorted + if not self.__allnames: + self.__allnames = [] + for name, aliases in self.__byrgb.values(): + self.__allnames.append(name) + self.__allnames.sort(key=str.lower) + return self.__allnames + + def aliases_of(self, red, green, blue): + try: + name, aliases = self.__byrgb[(red, green, blue)] + except KeyError: + raise BadColor((red, green, blue)) from None + return [name] + aliases + + +class RGBColorDB(ColorDB): + _re = re.compile( + r'\s*(?P\d+)\s+(?P\d+)\s+(?P\d+)\s+(?P.*)') + + +class HTML40DB(ColorDB): + _re = re.compile(r'(?P\S+)\s+(?P#[0-9a-fA-F]{6})') + + def _extractrgb(self, mo): + return rrggbb_to_triplet(mo.group('hexrgb')) + +class LightlinkDB(HTML40DB): + _re = re.compile(r'(?P(.+))\s+(?P#[0-9a-fA-F]{6})') + + def _extractname(self, mo): + return mo.group('name').strip() + +class WebsafeDB(ColorDB): + _re = re.compile('(?P#[0-9a-fA-F]{6})') + + def _extractrgb(self, mo): + return rrggbb_to_triplet(mo.group('hexrgb')) + + def _extractname(self, mo): + return mo.group('hexrgb').upper() + + + +# format is a tuple (RE, SCANLINES, CLASS) where RE is a compiled regular +# expression, SCANLINES is the number of header lines to scan, and CLASS is +# the class to instantiate if a match is found + +FILETYPES = [ + (re.compile('Xorg'), RGBColorDB), + (re.compile('XConsortium'), RGBColorDB), + (re.compile('HTML'), HTML40DB), + (re.compile('lightlink'), LightlinkDB), + (re.compile('Websafe'), WebsafeDB), + ] + +def get_colordb(file, filetype=None): + colordb = None + fp = open(file) + try: + line = fp.readline() + if not line: + return None + # try to determine the type of RGB file it is + if filetype is None: + filetypes = FILETYPES + else: + filetypes = [filetype] + for typere, class_ in filetypes: + mo = typere.search(line) + if mo: + break + else: + # no matching type + return None + # we know the type and the class to grok the type, so suck it in + colordb = class_(fp) + finally: + fp.close() + # save a global copy + global DEFAULT_DB + DEFAULT_DB = colordb + return colordb + + + +_namedict = {} + +def rrggbb_to_triplet(color): + """Converts a #rrggbb color to the tuple (red, green, blue).""" + rgbtuple = _namedict.get(color) + if rgbtuple is None: + if color[0] != '#': + raise BadColor(color) + red = color[1:3] + green = color[3:5] + blue = color[5:7] + rgbtuple = int(red, 16), int(green, 16), int(blue, 16) + _namedict[color] = rgbtuple + return rgbtuple + + +_tripdict = {} +def triplet_to_rrggbb(rgbtuple): + """Converts a (red, green, blue) tuple to #rrggbb.""" + global _tripdict + hexname = _tripdict.get(rgbtuple) + if hexname is None: + hexname = '#%02x%02x%02x' % rgbtuple + _tripdict[rgbtuple] = hexname + return hexname + + +def triplet_to_fractional_rgb(rgbtuple): + return [x / 256 for x in rgbtuple] + + +def triplet_to_brightness(rgbtuple): + # return the brightness (grey level) along the scale 0.0==black to + # 1.0==white + r = 0.299 + g = 0.587 + b = 0.114 + return r*rgbtuple[0] + g*rgbtuple[1] + b*rgbtuple[2] + + + +if __name__ == '__main__': + colordb = get_colordb('/usr/openwin/lib/rgb.txt') + if not colordb: + print('No parseable color database found') + sys.exit(1) + # on my system, this color matches exactly + target = 'navy' + red, green, blue = rgbtuple = colordb.find_byname(target) + print(target, ':', red, green, blue, triplet_to_rrggbb(rgbtuple)) + name, aliases = colordb.find_byrgb(rgbtuple) + print('name:', name, 'aliases:', COMMASPACE.join(aliases)) + r, g, b = (1, 1, 128) # nearest to navy + r, g, b = (145, 238, 144) # nearest to lightgreen + r, g, b = (255, 251, 250) # snow + print('finding nearest to', target, '...') + import time + t0 = time.time() + nearest = colordb.nearest(r, g, b) + t1 = time.time() + print('found nearest color', nearest, 'in', t1-t0, 'seconds') + # dump the database + for n in colordb.unique_names(): + r, g, b = colordb.find_byname(n) + aliases = colordb.aliases_of(r, g, b) + print('%20s: (%3d/%3d/%3d) == %s' % (n, r, g, b, + SPACE.join(aliases[1:]))) diff --git a/marketing/Tools/pynche/DetailsViewer.py b/marketing/Tools/pynche/DetailsViewer.py new file mode 100644 index 0000000000000000000000000000000000000000..bed11f4f4efdf0ba56abb6ea5f92d25b1adec6f9 --- /dev/null +++ b/marketing/Tools/pynche/DetailsViewer.py @@ -0,0 +1,273 @@ +"""DetailsViewer class. + +This class implements a pure input window which allows you to meticulously +edit the current color. You have both mouse control of the color (via the +buttons along the bottom row), and there are keyboard bindings for each of the +increment/decrement buttons. + +The top three check buttons allow you to specify which of the three color +variations are tied together when incrementing and decrementing. Red, green, +and blue are self evident. By tying together red and green, you can modify +the yellow level of the color. By tying together red and blue, you can modify +the magenta level of the color. By tying together green and blue, you can +modify the cyan level, and by tying all three together, you can modify the +grey level. + +The behavior at the boundaries (0 and 255) are defined by the `At boundary' +option menu: + + Stop + When the increment or decrement would send any of the tied variations + out of bounds, the entire delta is discarded. + + Wrap Around + When the increment or decrement would send any of the tied variations + out of bounds, the out of bounds variation is wrapped around to the + other side. Thus if red were at 238 and 25 were added to it, red + would have the value 7. + + Preserve Distance + When the increment or decrement would send any of the tied variations + out of bounds, all tied variations are wrapped as one, so as to + preserve the distance between them. Thus if green and blue were tied, + and green was at 238 while blue was at 223, and an increment of 25 + were applied, green would be at 15 and blue would be at 0. + + Squash + When the increment or decrement would send any of the tied variations + out of bounds, the out of bounds variation is set to the ceiling of + 255 or floor of 0, as appropriate. In this way, all tied variations + are squashed to one edge or the other. + +The following key bindings can be used as accelerators. Note that Pynche can +fall behind if you hold the key down as a key repeat: + +Left arrow == -1 +Right arrow == +1 + +Control + Left == -10 +Control + Right == 10 + +Shift + Left == -25 +Shift + Right == +25 +""" + +from tkinter import * + +STOP = 'Stop' +WRAP = 'Wrap Around' +RATIO = 'Preserve Distance' +GRAV = 'Squash' + +ADDTOVIEW = 'Details Window...' + + +class DetailsViewer: + def __init__(self, switchboard, master=None): + self.__sb = switchboard + optiondb = switchboard.optiondb() + self.__red, self.__green, self.__blue = switchboard.current_rgb() + # GUI + root = self.__root = Toplevel(master, class_='Pynche') + root.protocol('WM_DELETE_WINDOW', self.withdraw) + root.title('Pynche Details Window') + root.iconname('Pynche Details Window') + root.bind('', self.__quit) + root.bind('', self.__quit) + root.bind('', self.withdraw) + root.bind('', self.withdraw) + # accelerators + root.bind('', self.__minus1) + root.bind('', self.__plus1) + root.bind('', self.__minus10) + root.bind('', self.__plus10) + root.bind('', self.__minus25) + root.bind('', self.__plus25) + # + # color ties + frame = self.__frame = Frame(root) + frame.pack(expand=YES, fill=X) + self.__l1 = Label(frame, text='Move Sliders:') + self.__l1.grid(row=1, column=0, sticky=E) + self.__rvar = IntVar() + self.__rvar.set(optiondb.get('RSLIDER', 4)) + self.__radio1 = Checkbutton(frame, text='Red', + variable=self.__rvar, + command=self.__effect, + onvalue=4, offvalue=0) + self.__radio1.grid(row=1, column=1, sticky=W) + self.__gvar = IntVar() + self.__gvar.set(optiondb.get('GSLIDER', 2)) + self.__radio2 = Checkbutton(frame, text='Green', + variable=self.__gvar, + command=self.__effect, + onvalue=2, offvalue=0) + self.__radio2.grid(row=2, column=1, sticky=W) + self.__bvar = IntVar() + self.__bvar.set(optiondb.get('BSLIDER', 1)) + self.__radio3 = Checkbutton(frame, text='Blue', + variable=self.__bvar, + command=self.__effect, + onvalue=1, offvalue=0) + self.__radio3.grid(row=3, column=1, sticky=W) + self.__l2 = Label(frame) + self.__l2.grid(row=4, column=1, sticky=W) + self.__effect() + # + # Boundary behavior + self.__l3 = Label(frame, text='At boundary:') + self.__l3.grid(row=5, column=0, sticky=E) + self.__boundvar = StringVar() + self.__boundvar.set(optiondb.get('ATBOUND', STOP)) + self.__omenu = OptionMenu(frame, self.__boundvar, + STOP, WRAP, RATIO, GRAV) + self.__omenu.grid(row=5, column=1, sticky=W) + self.__omenu.configure(width=17) + # + # Buttons + frame = self.__btnframe = Frame(frame) + frame.grid(row=0, column=0, columnspan=2, sticky='EW') + self.__down25 = Button(frame, text='-25', + command=self.__minus25) + self.__down10 = Button(frame, text='-10', + command=self.__minus10) + self.__down1 = Button(frame, text='-1', + command=self.__minus1) + self.__up1 = Button(frame, text='+1', + command=self.__plus1) + self.__up10 = Button(frame, text='+10', + command=self.__plus10) + self.__up25 = Button(frame, text='+25', + command=self.__plus25) + self.__down25.pack(expand=YES, fill=X, side=LEFT) + self.__down10.pack(expand=YES, fill=X, side=LEFT) + self.__down1.pack(expand=YES, fill=X, side=LEFT) + self.__up1.pack(expand=YES, fill=X, side=LEFT) + self.__up10.pack(expand=YES, fill=X, side=LEFT) + self.__up25.pack(expand=YES, fill=X, side=LEFT) + + def __effect(self, event=None): + tie = self.__rvar.get() + self.__gvar.get() + self.__bvar.get() + if tie in (0, 1, 2, 4): + text = '' + else: + text = '(= %s Level)' % {3: 'Cyan', + 5: 'Magenta', + 6: 'Yellow', + 7: 'Grey'}[tie] + self.__l2.configure(text=text) + + def __quit(self, event=None): + self.__root.quit() + + def withdraw(self, event=None): + self.__root.withdraw() + + def deiconify(self, event=None): + self.__root.deiconify() + + def __minus25(self, event=None): + self.__delta(-25) + + def __minus10(self, event=None): + self.__delta(-10) + + def __minus1(self, event=None): + self.__delta(-1) + + def __plus1(self, event=None): + self.__delta(1) + + def __plus10(self, event=None): + self.__delta(10) + + def __plus25(self, event=None): + self.__delta(25) + + def __delta(self, delta): + tie = [] + if self.__rvar.get(): + red = self.__red + delta + tie.append(red) + else: + red = self.__red + if self.__gvar.get(): + green = self.__green + delta + tie.append(green) + else: + green = self.__green + if self.__bvar.get(): + blue = self.__blue + delta + tie.append(blue) + else: + blue = self.__blue + # now apply at boundary behavior + atbound = self.__boundvar.get() + if atbound == STOP: + if red < 0 or green < 0 or blue < 0 or \ + red > 255 or green > 255 or blue > 255: + # then + red, green, blue = self.__red, self.__green, self.__blue + elif atbound == WRAP or (atbound == RATIO and len(tie) < 2): + if red < 0: + red += 256 + if green < 0: + green += 256 + if blue < 0: + blue += 256 + if red > 255: + red -= 256 + if green > 255: + green -= 256 + if blue > 255: + blue -= 256 + elif atbound == RATIO: + # for when 2 or 3 colors are tied together + dir = 0 + for c in tie: + if c < 0: + dir = -1 + elif c > 255: + dir = 1 + if dir == -1: + delta = max(tie) + if self.__rvar.get(): + red = red + 255 - delta + if self.__gvar.get(): + green = green + 255 - delta + if self.__bvar.get(): + blue = blue + 255 - delta + elif dir == 1: + delta = min(tie) + if self.__rvar.get(): + red = red - delta + if self.__gvar.get(): + green = green - delta + if self.__bvar.get(): + blue = blue - delta + elif atbound == GRAV: + if red < 0: + red = 0 + if green < 0: + green = 0 + if blue < 0: + blue = 0 + if red > 255: + red = 255 + if green > 255: + green = 255 + if blue > 255: + blue = 255 + self.__sb.update_views(red, green, blue) + self.__root.update_idletasks() + + def update_yourself(self, red, green, blue): + self.__red = red + self.__green = green + self.__blue = blue + + def save_options(self, optiondb): + optiondb['RSLIDER'] = self.__rvar.get() + optiondb['GSLIDER'] = self.__gvar.get() + optiondb['BSLIDER'] = self.__bvar.get() + optiondb['ATBOUND'] = self.__boundvar.get() diff --git a/marketing/Tools/pynche/ListViewer.py b/marketing/Tools/pynche/ListViewer.py new file mode 100644 index 0000000000000000000000000000000000000000..b18784453c3e02b683cdc3a9fdebbe741cb1914e --- /dev/null +++ b/marketing/Tools/pynche/ListViewer.py @@ -0,0 +1,175 @@ +"""ListViewer class. + +This class implements an input/output view on the color model. It lists every +unique color (e.g. unique r/g/b value) found in the color database. Each +color is shown by small swatch and primary color name. Some colors have +aliases -- more than one name for the same r/g/b value. These aliases are +displayed in the small listbox at the bottom of the screen. + +Clicking on a color name or swatch selects that color and updates all other +windows. When a color is selected in a different viewer, the color list is +scrolled to the selected color and it is highlighted. If the selected color +is an r/g/b value without a name, no scrolling occurs. + +You can turn off Update On Click if all you want to see is the alias for a +given name, without selecting the color. +""" + +from tkinter import * +import ColorDB + +ADDTOVIEW = 'Color %List Window...' + +class ListViewer: + def __init__(self, switchboard, master=None): + self.__sb = switchboard + optiondb = switchboard.optiondb() + self.__lastbox = None + self.__dontcenter = 0 + # GUI + root = self.__root = Toplevel(master, class_='Pynche') + root.protocol('WM_DELETE_WINDOW', self.withdraw) + root.title('Pynche Color List') + root.iconname('Pynche Color List') + root.bind('', self.__quit) + root.bind('', self.__quit) + root.bind('', self.withdraw) + root.bind('', self.withdraw) + # + # create the canvas which holds everything, and its scrollbar + # + frame = self.__frame = Frame(root) + frame.pack() + canvas = self.__canvas = Canvas(frame, width=160, height=300, + borderwidth=2, relief=SUNKEN) + self.__scrollbar = Scrollbar(frame) + self.__scrollbar.pack(fill=Y, side=RIGHT) + canvas.pack(fill=BOTH, expand=1) + canvas.configure(yscrollcommand=(self.__scrollbar, 'set')) + self.__scrollbar.configure(command=(canvas, 'yview')) + self.__populate() + # + # Update on click + self.__uoc = BooleanVar() + self.__uoc.set(optiondb.get('UPONCLICK', 1)) + self.__uocbtn = Checkbutton(root, + text='Update on Click', + variable=self.__uoc, + command=self.__toggleupdate) + self.__uocbtn.pack(expand=1, fill=BOTH) + # + # alias list + self.__alabel = Label(root, text='Aliases:') + self.__alabel.pack() + self.__aliases = Listbox(root, height=5, + selectmode=BROWSE) + self.__aliases.pack(expand=1, fill=BOTH) + + def __populate(self): + # + # create all the buttons + colordb = self.__sb.colordb() + canvas = self.__canvas + row = 0 + widest = 0 + bboxes = self.__bboxes = [] + for name in colordb.unique_names(): + exactcolor = ColorDB.triplet_to_rrggbb(colordb.find_byname(name)) + canvas.create_rectangle(5, row*20 + 5, + 20, row*20 + 20, + fill=exactcolor) + textid = canvas.create_text(25, row*20 + 13, + text=name, + anchor=W) + x1, y1, textend, y2 = canvas.bbox(textid) + boxid = canvas.create_rectangle(3, row*20+3, + textend+3, row*20 + 23, + outline='', + tags=(exactcolor, 'all')) + canvas.bind('', self.__onrelease) + bboxes.append(boxid) + if textend+3 > widest: + widest = textend+3 + row += 1 + canvheight = (row-1)*20 + 25 + canvas.config(scrollregion=(0, 0, 150, canvheight)) + for box in bboxes: + x1, y1, x2, y2 = canvas.coords(box) + canvas.coords(box, x1, y1, widest, y2) + + def __onrelease(self, event=None): + canvas = self.__canvas + # find the current box + x = canvas.canvasx(event.x) + y = canvas.canvasy(event.y) + ids = canvas.find_overlapping(x, y, x, y) + for boxid in ids: + if boxid in self.__bboxes: + break + else: +## print 'No box found!' + return + tags = self.__canvas.gettags(boxid) + for t in tags: + if t[0] == '#': + break + else: +## print 'No color tag found!' + return + red, green, blue = ColorDB.rrggbb_to_triplet(t) + self.__dontcenter = 1 + if self.__uoc.get(): + self.__sb.update_views(red, green, blue) + else: + self.update_yourself(red, green, blue) + self.__red, self.__green, self.__blue = red, green, blue + + def __toggleupdate(self, event=None): + if self.__uoc.get(): + self.__sb.update_views(self.__red, self.__green, self.__blue) + + def __quit(self, event=None): + self.__root.quit() + + def withdraw(self, event=None): + self.__root.withdraw() + + def deiconify(self, event=None): + self.__root.deiconify() + + def update_yourself(self, red, green, blue): + canvas = self.__canvas + # turn off the last box + if self.__lastbox: + canvas.itemconfigure(self.__lastbox, outline='') + # turn on the current box + colortag = ColorDB.triplet_to_rrggbb((red, green, blue)) + canvas.itemconfigure(colortag, outline='black') + self.__lastbox = colortag + # fill the aliases + self.__aliases.delete(0, END) + try: + aliases = self.__sb.colordb().aliases_of(red, green, blue)[1:] + except ColorDB.BadColor: + self.__aliases.insert(END, '') + return + if not aliases: + self.__aliases.insert(END, '') + else: + for name in aliases: + self.__aliases.insert(END, name) + # maybe scroll the canvas so that the item is visible + if self.__dontcenter: + self.__dontcenter = 0 + else: + ig, ig, ig, y1 = canvas.coords(colortag) + ig, ig, ig, y2 = canvas.coords(self.__bboxes[-1]) + h = int(canvas['height']) * 0.5 + canvas.yview('moveto', (y1-h) / y2) + + def save_options(self, optiondb): + optiondb['UPONCLICK'] = self.__uoc.get() + + def colordb_changed(self, colordb): + self.__canvas.delete('all') + self.__populate() diff --git a/marketing/Tools/pynche/Main.py b/marketing/Tools/pynche/Main.py new file mode 100644 index 0000000000000000000000000000000000000000..4db560b568179cd83eba1b0b9b85fc75467b2ec3 --- /dev/null +++ b/marketing/Tools/pynche/Main.py @@ -0,0 +1,229 @@ +"""Pynche -- The PYthon Natural Color and Hue Editor. + +Contact: %(AUTHNAME)s +Email: %(AUTHEMAIL)s +Version: %(__version__)s + +Pynche is based largely on a similar color editor I wrote years ago for the +SunView window system. That editor was called ICE: the Interactive Color +Editor. I'd always wanted to port the editor to X but didn't feel like +hacking X and C code to do it. Fast forward many years, to where Python + +Tkinter provides such a nice programming environment, with enough power, that +I finally buckled down and implemented it. I changed the name because these +days, too many other systems have the acronym `ICE'. + +This program currently requires Python 2.2 with Tkinter. + +Usage: %(PROGRAM)s [-d file] [-i file] [-X] [-v] [-h] [initialcolor] + +Where: + --database file + -d file + Alternate location of a color database file + + --initfile file + -i file + Alternate location of the initialization file. This file contains a + persistent database of the current Pynche options and color. This + means that Pynche restores its option settings and current color when + it restarts, using this file (unless the -X option is used). The + default is ~/.pynche + + --ignore + -X + Ignore the initialization file when starting up. Pynche will still + write the current option settings to this file when it quits. + + --version + -v + print the version number and exit + + --help + -h + print this message + + initialcolor + initial color, as a color name or #RRGGBB format +""" + +__version__ = '1.4.1' + +import sys +import os +import getopt +import ColorDB + +from PyncheWidget import PyncheWidget +from Switchboard import Switchboard +from StripViewer import StripViewer +from ChipViewer import ChipViewer +from TypeinViewer import TypeinViewer + + + +PROGRAM = sys.argv[0] +AUTHNAME = 'Barry Warsaw' +AUTHEMAIL = 'barry@python.org' + +# Default locations of rgb.txt or other textual color database +RGB_TXT = [ + # Solaris OpenWindows + '/usr/openwin/lib/rgb.txt', + # Linux + '/usr/lib/X11/rgb.txt', + # The X11R6.4 rgb.txt file + os.path.join(sys.path[0], 'X/rgb.txt'), + # add more here + ] + + + +# Do this because PyncheWidget.py wants to get at the interpolated docstring +# too, for its Help menu. +def docstring(): + return __doc__ % globals() + + +def usage(code, msg=''): + print(docstring()) + if msg: + print(msg) + sys.exit(code) + + + +def initial_color(s, colordb): + # function called on every color + def scan_color(s, colordb=colordb): + try: + r, g, b = colordb.find_byname(s) + except ColorDB.BadColor: + try: + r, g, b = ColorDB.rrggbb_to_triplet(s) + except ColorDB.BadColor: + return None, None, None + return r, g, b + # + # First try the passed in color + r, g, b = scan_color(s) + if r is None: + # try the same color with '#' prepended, since some shells require + # this to be escaped, which is a pain + r, g, b = scan_color('#' + s) + if r is None: + print('Bad initial color, using gray50:', s) + r, g, b = scan_color('gray50') + if r is None: + usage(1, 'Cannot find an initial color to use') + # does not return + return r, g, b + + + +def build(master=None, initialcolor=None, initfile=None, ignore=None, + dbfile=None): + # create all output widgets + s = Switchboard(not ignore and initfile) + # defer to the command line chosen color database, falling back to the one + # in the .pynche file. + if dbfile is None: + dbfile = s.optiondb().get('DBFILE') + # find a parseable color database + colordb = None + files = RGB_TXT[:] + if dbfile is None: + dbfile = files.pop() + while colordb is None: + try: + colordb = ColorDB.get_colordb(dbfile) + except (KeyError, IOError): + pass + if colordb is None: + if not files: + break + dbfile = files.pop(0) + if not colordb: + usage(1, 'No color database file found, see the -d option.') + s.set_colordb(colordb) + + # create the application window decorations + app = PyncheWidget(__version__, s, master=master) + w = app.window() + + # these built-in viewers live inside the main Pynche window + s.add_view(StripViewer(s, w)) + s.add_view(ChipViewer(s, w)) + s.add_view(TypeinViewer(s, w)) + + # get the initial color as components and set the color on all views. if + # there was no initial color given on the command line, use the one that's + # stored in the option database + if initialcolor is None: + optiondb = s.optiondb() + red = optiondb.get('RED') + green = optiondb.get('GREEN') + blue = optiondb.get('BLUE') + # but if there wasn't any stored in the database, use grey50 + if red is None or blue is None or green is None: + red, green, blue = initial_color('grey50', colordb) + else: + red, green, blue = initial_color(initialcolor, colordb) + s.update_views(red, green, blue) + return app, s + + +def run(app, s): + try: + app.start() + except KeyboardInterrupt: + pass + + + +def main(): + try: + opts, args = getopt.getopt( + sys.argv[1:], + 'hd:i:Xv', + ['database=', 'initfile=', 'ignore', 'help', 'version']) + except getopt.error as msg: + usage(1, msg) + + if len(args) == 0: + initialcolor = None + elif len(args) == 1: + initialcolor = args[0] + else: + usage(1) + + ignore = False + dbfile = None + initfile = os.path.expanduser('~/.pynche') + for opt, arg in opts: + if opt in ('-h', '--help'): + usage(0) + elif opt in ('-v', '--version'): + print("""\ +Pynche -- The PYthon Natural Color and Hue Editor. +Contact: %(AUTHNAME)s +Email: %(AUTHEMAIL)s +Version: %(__version__)s""" % globals()) + sys.exit(0) + elif opt in ('-d', '--database'): + dbfile = arg + elif opt in ('-X', '--ignore'): + ignore = True + elif opt in ('-i', '--initfile'): + initfile = arg + + app, sb = build(initialcolor=initialcolor, + initfile=initfile, + ignore=ignore, + dbfile=dbfile) + run(app, sb) + sb.save_views() + + + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/pynche/PyncheWidget.py b/marketing/Tools/pynche/PyncheWidget.py new file mode 100644 index 0000000000000000000000000000000000000000..ea456e577e12a991a265ed0df98adcffc2940afa --- /dev/null +++ b/marketing/Tools/pynche/PyncheWidget.py @@ -0,0 +1,313 @@ +"""Main Pynche (Pythonically Natural Color and Hue Editor) widget. + +This window provides the basic decorations, primarily including the menubar. +It is used to bring up other windows. +""" + +import sys +import os +from tkinter import * +from tkinter import messagebox, filedialog +import ColorDB + +# Milliseconds between interrupt checks +KEEPALIVE_TIMER = 500 + + + +class PyncheWidget: + def __init__(self, version, switchboard, master=None, extrapath=[]): + self.__sb = switchboard + self.__version = version + self.__textwin = None + self.__listwin = None + self.__detailswin = None + self.__helpwin = None + self.__dialogstate = {} + modal = self.__modal = not not master + # If a master was given, we are running as a modal dialog servant to + # some other application. We rearrange our UI in this case (there's + # no File menu and we get `Okay' and `Cancel' buttons), and we do a + # grab_set() to make ourselves modal + if modal: + self.__tkroot = tkroot = Toplevel(master, class_='Pynche') + tkroot.grab_set() + tkroot.withdraw() + else: + # Is there already a default root for Tk, say because we're + # running under Guido's IDE? :-) Two conditions say no, either the + # _default_root is None or it is unset. + tkroot = getattr(tkinter, '_default_root', None) + if not tkroot: + tkroot = Tk(className='Pynche') + self.__tkroot = tkroot + # but this isn't our top level widget, so make it invisible + tkroot.withdraw() + # create the menubar + menubar = self.__menubar = Menu(tkroot) + # + # File menu + # + filemenu = self.__filemenu = Menu(menubar, tearoff=0) + filemenu.add_command(label='Load palette...', + command=self.__load, + underline=0) + if not modal: + filemenu.add_command(label='Quit', + command=self.__quit, + accelerator='Alt-Q', + underline=0) + # + # View menu + # + views = make_view_popups(self.__sb, self.__tkroot, extrapath) + viewmenu = Menu(menubar, tearoff=0) + for v in views: + viewmenu.add_command(label=v.menutext(), + command=v.popup, + underline=v.underline()) + # + # Help menu + # + helpmenu = Menu(menubar, name='help', tearoff=0) + helpmenu.add_command(label='About Pynche...', + command=self.__popup_about, + underline=0) + helpmenu.add_command(label='Help...', + command=self.__popup_usage, + underline=0) + # + # Tie them all together + # + menubar.add_cascade(label='File', + menu=filemenu, + underline=0) + menubar.add_cascade(label='View', + menu=viewmenu, + underline=0) + menubar.add_cascade(label='Help', + menu=helpmenu, + underline=0) + + # now create the top level window + root = self.__root = Toplevel(tkroot, class_='Pynche', menu=menubar) + root.protocol('WM_DELETE_WINDOW', + modal and self.__bell or self.__quit) + root.title('Pynche %s' % version) + root.iconname('Pynche') + # Only bind accelerators for the File->Quit menu item if running as a + # standalone app + if not modal: + root.bind('', self.__quit) + root.bind('', self.__quit) + else: + # We're a modal dialog so we have a new row of buttons + bframe = Frame(root, borderwidth=1, relief=RAISED) + bframe.grid(row=4, column=0, columnspan=2, + sticky='EW', + ipady=5) + okay = Button(bframe, + text='Okay', + command=self.__okay) + okay.pack(side=LEFT, expand=1) + cancel = Button(bframe, + text='Cancel', + command=self.__cancel) + cancel.pack(side=LEFT, expand=1) + + def __quit(self, event=None): + self.__tkroot.quit() + + def __bell(self, event=None): + self.__tkroot.bell() + + def __okay(self, event=None): + self.__sb.withdraw_views() + self.__tkroot.grab_release() + self.__quit() + + def __cancel(self, event=None): + self.__sb.canceled() + self.__okay() + + def __keepalive(self): + # Exercise the Python interpreter regularly so keyboard interrupts get + # through. + self.__tkroot.tk.createtimerhandler(KEEPALIVE_TIMER, self.__keepalive) + + def start(self): + if not self.__modal: + self.__keepalive() + self.__tkroot.mainloop() + + def window(self): + return self.__root + + def __popup_about(self, event=None): + from Main import __version__ + messagebox.showinfo('About Pynche ' + __version__, + '''\ +Pynche %s +The PYthonically Natural +Color and Hue Editor + +For information +contact: Barry A. Warsaw +email: bwarsaw@python.org''' % __version__) + + def __popup_usage(self, event=None): + if not self.__helpwin: + self.__helpwin = Helpwin(self.__root, self.__quit) + self.__helpwin.deiconify() + + def __load(self, event=None): + while 1: + idir, ifile = os.path.split(self.__sb.colordb().filename()) + file = filedialog.askopenfilename( + filetypes=[('Text files', '*.txt'), + ('All files', '*'), + ], + initialdir=idir, + initialfile=ifile) + if not file: + # cancel button + return + try: + colordb = ColorDB.get_colordb(file) + except IOError: + messagebox.showerror('Read error', '''\ +Could not open file for reading: +%s''' % file) + continue + if colordb is None: + messagebox.showerror('Unrecognized color file type', '''\ +Unrecognized color file type in file: +%s''' % file) + continue + break + self.__sb.set_colordb(colordb) + + def withdraw(self): + self.__root.withdraw() + + def deiconify(self): + self.__root.deiconify() + + + +class Helpwin: + def __init__(self, master, quitfunc): + from Main import docstring + self.__root = root = Toplevel(master, class_='Pynche') + root.protocol('WM_DELETE_WINDOW', self.__withdraw) + root.title('Pynche Help Window') + root.iconname('Pynche Help Window') + root.bind('', quitfunc) + root.bind('', quitfunc) + root.bind('', self.__withdraw) + root.bind('', self.__withdraw) + + # more elaborate help is available in the README file + readmefile = os.path.join(sys.path[0], 'README') + try: + fp = None + try: + fp = open(readmefile) + contents = fp.read() + # wax the last page, it contains Emacs cruft + i = contents.rfind('\f') + if i > 0: + contents = contents[:i].rstrip() + finally: + if fp: + fp.close() + except IOError: + sys.stderr.write("Couldn't open Pynche's README, " + 'using docstring instead.\n') + contents = docstring() + + self.__text = text = Text(root, relief=SUNKEN, + width=80, height=24) + self.__text.focus_set() + text.insert(0.0, contents) + scrollbar = Scrollbar(root) + scrollbar.pack(fill=Y, side=RIGHT) + text.pack(fill=BOTH, expand=YES) + text.configure(yscrollcommand=(scrollbar, 'set')) + scrollbar.configure(command=(text, 'yview')) + + def __withdraw(self, event=None): + self.__root.withdraw() + + def deiconify(self): + self.__root.deiconify() + + + +import functools +@functools.total_ordering +class PopupViewer: + def __init__(self, module, name, switchboard, root): + self.__m = module + self.__name = name + self.__sb = switchboard + self.__root = root + self.__menutext = module.ADDTOVIEW + # find the underline character + underline = module.ADDTOVIEW.find('%') + if underline == -1: + underline = 0 + else: + self.__menutext = module.ADDTOVIEW.replace('%', '', 1) + self.__underline = underline + self.__window = None + + def menutext(self): + return self.__menutext + + def underline(self): + return self.__underline + + def popup(self, event=None): + if not self.__window: + # class and module must have the same name + class_ = getattr(self.__m, self.__name) + self.__window = class_(self.__sb, self.__root) + self.__sb.add_view(self.__window) + self.__window.deiconify() + + def __eq__(self, other): + if isinstance(self, PopupViewer): + return self.__menutext == other.__menutext + return NotImplemented + + def __lt__(self, other): + if isinstance(self, PopupViewer): + return self.__menutext < other.__menutext + return NotImplemented + + +def make_view_popups(switchboard, root, extrapath): + viewers = [] + # where we are in the file system + dirs = [os.path.dirname(__file__)] + extrapath + for dir in dirs: + if dir == '': + dir = '.' + for file in os.listdir(dir): + if file[-9:] == 'Viewer.py': + name = file[:-3] + try: + module = __import__(name) + except ImportError: + # Pynche is running from inside a package, so get the + # module using the explicit path. + pkg = __import__('pynche.'+name) + module = getattr(pkg, name) + if hasattr(module, 'ADDTOVIEW') and module.ADDTOVIEW: + # this is an external viewer + v = PopupViewer(module, name, switchboard, root) + viewers.append(v) + # sort alphabetically + viewers.sort() + return viewers diff --git a/marketing/Tools/pynche/StripViewer.py b/marketing/Tools/pynche/StripViewer.py new file mode 100644 index 0000000000000000000000000000000000000000..6914ca94b2bd36947a2b1128fe173fd63fdf0655 --- /dev/null +++ b/marketing/Tools/pynche/StripViewer.py @@ -0,0 +1,397 @@ +"""Strip viewer and related widgets. + +The classes in this file implement the StripViewer shown in the top two thirds +of the main Pynche window. It consists of three StripWidgets which display +the variations in red, green, and blue respectively of the currently selected +r/g/b color value. + +Each StripWidget shows the color variations that are reachable by varying an +axis of the currently selected color. So for example, if the color is + + (R,G,B)=(127,163,196) + +then the Red variations show colors from (0,163,196) to (255,163,196), the +Green variations show colors from (127,0,196) to (127,255,196), and the Blue +variations show colors from (127,163,0) to (127,163,255). + +The selected color is always visible in all three StripWidgets, and in fact +each StripWidget highlights the selected color, and has an arrow pointing to +the selected chip, which includes the value along that particular axis. + +Clicking on any chip in any StripWidget selects that color, and updates all +arrows and other windows. By toggling on Update while dragging, Pynche will +select the color under the cursor while you drag it, but be forewarned that +this can be slow. +""" + +from tkinter import * +import ColorDB + +# Load this script into the Tcl interpreter and call it in +# StripWidget.set_color(). This is about as fast as it can be with the +# current _tkinter.c interface, which doesn't support Tcl Objects. +TCLPROC = '''\ +proc setcolor {canv colors} { + set i 1 + foreach c $colors { + $canv itemconfigure $i -fill $c -outline $c + incr i + } +} +''' + +# Tcl event types +BTNDOWN = 4 +BTNUP = 5 +BTNDRAG = 6 + +SPACE = ' ' + + + +def constant(numchips): + step = 255.0 / (numchips - 1) + start = 0.0 + seq = [] + while numchips > 0: + seq.append(int(start)) + start = start + step + numchips = numchips - 1 + return seq + +# red variations, green+blue = cyan constant +def constant_red_generator(numchips, red, green, blue): + seq = constant(numchips) + return list(zip([red] * numchips, seq, seq)) + +# green variations, red+blue = magenta constant +def constant_green_generator(numchips, red, green, blue): + seq = constant(numchips) + return list(zip(seq, [green] * numchips, seq)) + +# blue variations, red+green = yellow constant +def constant_blue_generator(numchips, red, green, blue): + seq = constant(numchips) + return list(zip(seq, seq, [blue] * numchips)) + +# red variations, green+blue = cyan constant +def constant_cyan_generator(numchips, red, green, blue): + seq = constant(numchips) + return list(zip(seq, [green] * numchips, [blue] * numchips)) + +# green variations, red+blue = magenta constant +def constant_magenta_generator(numchips, red, green, blue): + seq = constant(numchips) + return list(zip([red] * numchips, seq, [blue] * numchips)) + +# blue variations, red+green = yellow constant +def constant_yellow_generator(numchips, red, green, blue): + seq = constant(numchips) + return list(zip([red] * numchips, [green] * numchips, seq)) + + + +class LeftArrow: + _ARROWWIDTH = 30 + _ARROWHEIGHT = 15 + _YOFFSET = 13 + _TEXTYOFFSET = 1 + _TAG = ('leftarrow',) + + def __init__(self, canvas, x): + self._canvas = canvas + self.__arrow, self.__text = self._create(x) + self.move_to(x) + + def _create(self, x): + arrow = self._canvas.create_line( + x, self._ARROWHEIGHT + self._YOFFSET, + x, self._YOFFSET, + x + self._ARROWWIDTH, self._YOFFSET, + arrow='first', + width=3.0, + tags=self._TAG) + text = self._canvas.create_text( + x + self._ARROWWIDTH + 13, + self._ARROWHEIGHT - self._TEXTYOFFSET, + tags=self._TAG, + text='128') + return arrow, text + + def _x(self): + coords = list(self._canvas.coords(self._TAG)) + assert coords + return coords[0] + + def move_to(self, x): + deltax = x - self._x() + self._canvas.move(self._TAG, deltax, 0) + + def set_text(self, text): + self._canvas.itemconfigure(self.__text, text=text) + + +class RightArrow(LeftArrow): + _TAG = ('rightarrow',) + + def _create(self, x): + arrow = self._canvas.create_line( + x, self._YOFFSET, + x + self._ARROWWIDTH, self._YOFFSET, + x + self._ARROWWIDTH, self._ARROWHEIGHT + self._YOFFSET, + arrow='last', + width=3.0, + tags=self._TAG) + text = self._canvas.create_text( + x - self._ARROWWIDTH + 15, # BAW: kludge + self._ARROWHEIGHT - self._TEXTYOFFSET, + justify=RIGHT, + text='128', + tags=self._TAG) + return arrow, text + + def _x(self): + coords = list(self._canvas.coords(self._TAG)) + assert coords + return coords[0] + self._ARROWWIDTH + + + +class StripWidget: + _CHIPHEIGHT = 50 + _CHIPWIDTH = 10 + _NUMCHIPS = 40 + + def __init__(self, switchboard, + master = None, + chipwidth = _CHIPWIDTH, + chipheight = _CHIPHEIGHT, + numchips = _NUMCHIPS, + generator = None, + axis = None, + label = '', + uwdvar = None, + hexvar = None): + # instance variables + self.__generator = generator + self.__axis = axis + self.__numchips = numchips + assert self.__axis in (0, 1, 2) + self.__uwd = uwdvar + self.__hexp = hexvar + # the last chip selected + self.__lastchip = None + self.__sb = switchboard + + canvaswidth = numchips * (chipwidth + 1) + canvasheight = chipheight + 43 # BAW: Kludge + + # create the canvas and pack it + canvas = self.__canvas = Canvas(master, + width=canvaswidth, + height=canvasheight, +## borderwidth=2, +## relief=GROOVE + ) + + canvas.pack() + canvas.bind('', self.__select_chip) + canvas.bind('', self.__select_chip) + canvas.bind('', self.__select_chip) + + # Load a proc into the Tcl interpreter. This is used in the + # set_color() method to speed up setting the chip colors. + canvas.tk.eval(TCLPROC) + + # create the color strip + chips = self.__chips = [] + x = 1 + y = 30 + tags = ('chip',) + for c in range(self.__numchips): + color = 'grey' + canvas.create_rectangle( + x, y, x+chipwidth, y+chipheight, + fill=color, outline=color, + tags=tags) + x = x + chipwidth + 1 # for outline + chips.append(color) + + # create the strip label + self.__label = canvas.create_text( + 3, y + chipheight + 8, + text=label, + anchor=W) + + # create the arrow and text item + chipx = self.__arrow_x(0) + self.__leftarrow = LeftArrow(canvas, chipx) + + chipx = self.__arrow_x(len(chips) - 1) + self.__rightarrow = RightArrow(canvas, chipx) + + def __arrow_x(self, chipnum): + coords = self.__canvas.coords(chipnum+1) + assert coords + x0, y0, x1, y1 = coords + return (x1 + x0) / 2.0 + + # Invoked when one of the chips is clicked. This should just tell the + # switchboard to set the color on all the output components + def __select_chip(self, event=None): + x = event.x + y = event.y + canvas = self.__canvas + chip = canvas.find_overlapping(x, y, x, y) + if chip and (1 <= chip[0] <= self.__numchips): + color = self.__chips[chip[0]-1] + red, green, blue = ColorDB.rrggbb_to_triplet(color) + etype = int(event.type) + if (etype == BTNUP or self.__uwd.get()): + # update everyone + self.__sb.update_views(red, green, blue) + else: + # just track the arrows + self.__trackarrow(chip[0], (red, green, blue)) + + def __trackarrow(self, chip, rgbtuple): + # invert the last chip + if self.__lastchip is not None: + color = self.__canvas.itemcget(self.__lastchip, 'fill') + self.__canvas.itemconfigure(self.__lastchip, outline=color) + self.__lastchip = chip + # get the arrow's text + coloraxis = rgbtuple[self.__axis] + if self.__hexp.get(): + # hex + text = hex(coloraxis) + else: + # decimal + text = repr(coloraxis) + # move the arrow, and set its text + if coloraxis <= 128: + # use the left arrow + self.__leftarrow.set_text(text) + self.__leftarrow.move_to(self.__arrow_x(chip-1)) + self.__rightarrow.move_to(-100) + else: + # use the right arrow + self.__rightarrow.set_text(text) + self.__rightarrow.move_to(self.__arrow_x(chip-1)) + self.__leftarrow.move_to(-100) + # and set the chip's outline + brightness = ColorDB.triplet_to_brightness(rgbtuple) + if brightness <= 128: + outline = 'white' + else: + outline = 'black' + self.__canvas.itemconfigure(chip, outline=outline) + + + def update_yourself(self, red, green, blue): + assert self.__generator + i = 1 + chip = 0 + chips = self.__chips = [] + tk = self.__canvas.tk + # get the red, green, and blue components for all chips + for t in self.__generator(self.__numchips, red, green, blue): + rrggbb = ColorDB.triplet_to_rrggbb(t) + chips.append(rrggbb) + tred, tgreen, tblue = t + if tred <= red and tgreen <= green and tblue <= blue: + chip = i + i = i + 1 + # call the raw tcl script + colors = SPACE.join(chips) + tk.eval('setcolor %s {%s}' % (self.__canvas._w, colors)) + # move the arrows around + self.__trackarrow(chip, (red, green, blue)) + + def set(self, label, generator): + self.__canvas.itemconfigure(self.__label, text=label) + self.__generator = generator + + +class StripViewer: + def __init__(self, switchboard, master=None): + self.__sb = switchboard + optiondb = switchboard.optiondb() + # create a frame inside the master. + frame = Frame(master, relief=RAISED, borderwidth=1) + frame.grid(row=1, column=0, columnspan=2, sticky='NSEW') + # create the options to be used later + uwd = self.__uwdvar = BooleanVar() + uwd.set(optiondb.get('UPWHILEDRAG', 0)) + hexp = self.__hexpvar = BooleanVar() + hexp.set(optiondb.get('HEXSTRIP', 0)) + # create the red, green, blue strips inside their own frame + frame1 = Frame(frame) + frame1.pack(expand=YES, fill=BOTH) + self.__reds = StripWidget(switchboard, frame1, + generator=constant_cyan_generator, + axis=0, + label='Red Variations', + uwdvar=uwd, hexvar=hexp) + + self.__greens = StripWidget(switchboard, frame1, + generator=constant_magenta_generator, + axis=1, + label='Green Variations', + uwdvar=uwd, hexvar=hexp) + + self.__blues = StripWidget(switchboard, frame1, + generator=constant_yellow_generator, + axis=2, + label='Blue Variations', + uwdvar=uwd, hexvar=hexp) + + # create a frame to contain the controls + frame2 = Frame(frame) + frame2.pack(expand=YES, fill=BOTH) + frame2.columnconfigure(0, weight=20) + frame2.columnconfigure(2, weight=20) + + padx = 8 + + # create the black button + blackbtn = Button(frame2, + text='Black', + command=self.__toblack) + blackbtn.grid(row=0, column=0, rowspan=2, sticky=W, padx=padx) + + # create the controls + uwdbtn = Checkbutton(frame2, + text='Update while dragging', + variable=uwd) + uwdbtn.grid(row=0, column=1, sticky=W) + hexbtn = Checkbutton(frame2, + text='Hexadecimal', + variable=hexp, + command=self.__togglehex) + hexbtn.grid(row=1, column=1, sticky=W) + + # create the white button + whitebtn = Button(frame2, + text='White', + command=self.__towhite) + whitebtn.grid(row=0, column=2, rowspan=2, sticky=E, padx=padx) + + def update_yourself(self, red, green, blue): + self.__reds.update_yourself(red, green, blue) + self.__greens.update_yourself(red, green, blue) + self.__blues.update_yourself(red, green, blue) + + def __togglehex(self, event=None): + red, green, blue = self.__sb.current_rgb() + self.update_yourself(red, green, blue) + + def __toblack(self, event=None): + self.__sb.update_views(0, 0, 0) + + def __towhite(self, event=None): + self.__sb.update_views(255, 255, 255) + + def save_options(self, optiondb): + optiondb['UPWHILEDRAG'] = self.__uwdvar.get() + optiondb['HEXSTRIP'] = self.__hexpvar.get() diff --git a/marketing/Tools/pynche/Switchboard.py b/marketing/Tools/pynche/Switchboard.py new file mode 100644 index 0000000000000000000000000000000000000000..013bb0138913916832f5a7085304f12230d9781c --- /dev/null +++ b/marketing/Tools/pynche/Switchboard.py @@ -0,0 +1,138 @@ +"""Switchboard class. + +This class is used to coordinate updates among all Viewers. Every Viewer must +conform to the following interface: + + - it must include a method called update_yourself() which takes three + arguments; the red, green, and blue values of the selected color. + + - When a Viewer selects a color and wishes to update all other Views, it + should call update_views() on the Switchboard object. Note that the + Viewer typically does *not* update itself before calling update_views(), + since this would cause it to get updated twice. + +Optionally, Viewers can also implement: + + - save_options() which takes an optiondb (a dictionary). Store into this + dictionary any values the Viewer wants to save in the persistent + ~/.pynche file. This dictionary is saved using marshal. The namespace + for the keys is ad-hoc; make sure you don't clobber some other Viewer's + keys! + + - withdraw() which takes no arguments. This is called when Pynche is + unmapped. All Viewers should implement this. + + - colordb_changed() which takes a single argument, an instance of + ColorDB. This is called whenever the color name database is changed and + gives a chance for the Viewers to do something on those events. See + ListViewer for details. + +External Viewers are found dynamically. Viewer modules should have names such +as FooViewer.py. If such a named module has a module global variable called +ADDTOVIEW and this variable is true, the Viewer will be added dynamically to +the `View' menu. ADDTOVIEW contains a string which is used as the menu item +to display the Viewer (one kludge: if the string contains a `%', this is used +to indicate that the next character will get an underline in the menu, +otherwise the first character is underlined). + +FooViewer.py should contain a class called FooViewer, and its constructor +should take two arguments, an instance of Switchboard, and optionally a Tk +master window. + +""" + +import sys +import marshal + + + +class Switchboard: + def __init__(self, initfile): + self.__initfile = initfile + self.__colordb = None + self.__optiondb = {} + self.__views = [] + self.__red = 0 + self.__green = 0 + self.__blue = 0 + self.__canceled = 0 + # read the initialization file + fp = None + if initfile: + try: + try: + fp = open(initfile, 'rb') + self.__optiondb = marshal.load(fp) + if not isinstance(self.__optiondb, dict): + print('Problem reading options from file:', initfile, + file=sys.stderr) + self.__optiondb = {} + except (IOError, EOFError, ValueError): + pass + finally: + if fp: + fp.close() + + def add_view(self, view): + self.__views.append(view) + + def update_views(self, red, green, blue): + self.__red = red + self.__green = green + self.__blue = blue + for v in self.__views: + v.update_yourself(red, green, blue) + + def update_views_current(self): + self.update_views(self.__red, self.__green, self.__blue) + + def current_rgb(self): + return self.__red, self.__green, self.__blue + + def colordb(self): + return self.__colordb + + def set_colordb(self, colordb): + self.__colordb = colordb + for v in self.__views: + if hasattr(v, 'colordb_changed'): + v.colordb_changed(colordb) + self.update_views_current() + + def optiondb(self): + return self.__optiondb + + def save_views(self): + # save the current color + self.__optiondb['RED'] = self.__red + self.__optiondb['GREEN'] = self.__green + self.__optiondb['BLUE'] = self.__blue + for v in self.__views: + if hasattr(v, 'save_options'): + v.save_options(self.__optiondb) + # save the name of the file used for the color database. we'll try to + # load this first. + self.__optiondb['DBFILE'] = self.__colordb.filename() + fp = None + try: + try: + fp = open(self.__initfile, 'wb') + except IOError: + print('Cannot write options to file:', \ + self.__initfile, file=sys.stderr) + else: + marshal.dump(self.__optiondb, fp) + finally: + if fp: + fp.close() + + def withdraw_views(self): + for v in self.__views: + if hasattr(v, 'withdraw'): + v.withdraw() + + def canceled(self, flag=1): + self.__canceled = flag + + def canceled_p(self): + return self.__canceled diff --git a/marketing/Tools/pynche/TextViewer.py b/marketing/Tools/pynche/TextViewer.py new file mode 100644 index 0000000000000000000000000000000000000000..baa1e62ca760309f3891a4aa5b4eb95fdf0100b3 --- /dev/null +++ b/marketing/Tools/pynche/TextViewer.py @@ -0,0 +1,188 @@ +"""TextViewer class. + +The TextViewer allows you to see how the selected color would affect various +characteristics of a Tk text widget. This is an output viewer only. + +In the top part of the window is a standard text widget with some sample text +in it. You are free to edit this text in any way you want (BAW: allow you to +change font characteristics). If you want changes in other viewers to update +text characteristics, turn on Track color changes. + +To select which characteristic tracks the change, select one of the radio +buttons in the window below. Text foreground and background affect the text +in the window above. The Selection is what you see when you click the middle +button and drag it through some text. The Insertion is the insertion cursor +in the text window (which only has a background). +""" + +from tkinter import * +import ColorDB + +ADDTOVIEW = 'Text Window...' + + + +class TextViewer: + def __init__(self, switchboard, master=None): + self.__sb = switchboard + optiondb = switchboard.optiondb() + root = self.__root = Toplevel(master, class_='Pynche') + root.protocol('WM_DELETE_WINDOW', self.withdraw) + root.title('Pynche Text Window') + root.iconname('Pynche Text Window') + root.bind('', self.__quit) + root.bind('', self.__quit) + root.bind('', self.withdraw) + root.bind('', self.withdraw) + # + # create the text widget + # + self.__text = Text(root, relief=SUNKEN, + background=optiondb.get('TEXTBG', 'black'), + foreground=optiondb.get('TEXTFG', 'white'), + width=35, height=15) + sfg = optiondb.get('TEXT_SFG') + if sfg: + self.__text.configure(selectforeground=sfg) + sbg = optiondb.get('TEXT_SBG') + if sbg: + self.__text.configure(selectbackground=sbg) + ibg = optiondb.get('TEXT_IBG') + if ibg: + self.__text.configure(insertbackground=ibg) + self.__text.pack() + self.__text.insert(0.0, optiondb.get('TEXT', '''\ +Insert some stuff here and play +with the buttons below to see +how the colors interact in +textual displays. + +See how the selection can also +be affected by tickling the buttons +and choosing a color.''')) + insert = optiondb.get('TEXTINS') + if insert: + self.__text.mark_set(INSERT, insert) + try: + start, end = optiondb.get('TEXTSEL', (6.0, END)) + self.__text.tag_add(SEL, start, end) + except ValueError: + # selection wasn't set + pass + self.__text.focus_set() + # + # variables + self.__trackp = BooleanVar() + self.__trackp.set(optiondb.get('TRACKP', 0)) + self.__which = IntVar() + self.__which.set(optiondb.get('WHICH', 0)) + # + # track toggle + self.__t = Checkbutton(root, text='Track color changes', + variable=self.__trackp, + relief=GROOVE, + command=self.__toggletrack) + self.__t.pack(fill=X, expand=YES) + frame = self.__frame = Frame(root) + frame.pack() + # + # labels + self.__labels = [] + row = 2 + for text in ('Text:', 'Selection:', 'Insertion:'): + l = Label(frame, text=text) + l.grid(row=row, column=0, sticky=E) + self.__labels.append(l) + row += 1 + col = 1 + for text in ('Foreground', 'Background'): + l = Label(frame, text=text) + l.grid(row=1, column=col) + self.__labels.append(l) + col += 1 + # + # radios + self.__radios = [] + for col in (1, 2): + for row in (2, 3, 4): + # there is no insertforeground option + if row==4 and col==1: + continue + r = Radiobutton(frame, variable=self.__which, + value=(row-2)*2 + col-1, + command=self.__set_color) + r.grid(row=row, column=col) + self.__radios.append(r) + self.__toggletrack() + + def __quit(self, event=None): + self.__root.quit() + + def withdraw(self, event=None): + self.__root.withdraw() + + def deiconify(self, event=None): + self.__root.deiconify() + + def __forceupdate(self, event=None): + self.__sb.update_views_current() + + def __toggletrack(self, event=None): + if self.__trackp.get(): + state = NORMAL + fg = self.__radios[0]['foreground'] + else: + state = DISABLED + fg = self.__radios[0]['disabledforeground'] + for r in self.__radios: + r.configure(state=state) + for l in self.__labels: + l.configure(foreground=fg) + + def __set_color(self, event=None): + which = self.__which.get() + text = self.__text + if which == 0: + color = text['foreground'] + elif which == 1: + color = text['background'] + elif which == 2: + color = text['selectforeground'] + elif which == 3: + color = text['selectbackground'] + elif which == 5: + color = text['insertbackground'] + try: + red, green, blue = ColorDB.rrggbb_to_triplet(color) + except ColorDB.BadColor: + # must have been a color name + red, green, blue = self.__sb.colordb().find_byname(color) + self.__sb.update_views(red, green, blue) + + def update_yourself(self, red, green, blue): + if self.__trackp.get(): + colorname = ColorDB.triplet_to_rrggbb((red, green, blue)) + which = self.__which.get() + text = self.__text + if which == 0: + text.configure(foreground=colorname) + elif which == 1: + text.configure(background=colorname) + elif which == 2: + text.configure(selectforeground=colorname) + elif which == 3: + text.configure(selectbackground=colorname) + elif which == 5: + text.configure(insertbackground=colorname) + + def save_options(self, optiondb): + optiondb['TRACKP'] = self.__trackp.get() + optiondb['WHICH'] = self.__which.get() + optiondb['TEXT'] = self.__text.get(0.0, 'end - 1c') + optiondb['TEXTSEL'] = self.__text.tag_ranges(SEL)[0:2] + optiondb['TEXTINS'] = self.__text.index(INSERT) + optiondb['TEXTFG'] = self.__text['foreground'] + optiondb['TEXTBG'] = self.__text['background'] + optiondb['TEXT_SFG'] = self.__text['selectforeground'] + optiondb['TEXT_SBG'] = self.__text['selectbackground'] + optiondb['TEXT_IBG'] = self.__text['insertbackground'] diff --git a/marketing/Tools/pynche/TypeinViewer.py b/marketing/Tools/pynche/TypeinViewer.py new file mode 100644 index 0000000000000000000000000000000000000000..2f93e6b44f4acb53dc94e802edfa9cb0532b720a --- /dev/null +++ b/marketing/Tools/pynche/TypeinViewer.py @@ -0,0 +1,161 @@ +"""TypeinViewer class. + +The TypeinViewer is what you see at the lower right of the main Pynche +widget. It contains three text entry fields, one each for red, green, blue. +Input into these windows is highly constrained; it only allows you to enter +values that are legal for a color axis. This usually means 0-255 for decimal +input and 0x0 - 0xff for hex input. + +You can toggle whether you want to view and input the values in either decimal +or hex by clicking on Hexadecimal. By clicking on Update while typing, the +color selection will be made on every change to the text field. Otherwise, +you must hit Return or Tab to select the color. +""" + +from tkinter import * + + + +class TypeinViewer: + def __init__(self, switchboard, master=None): + # non-gui ivars + self.__sb = switchboard + optiondb = switchboard.optiondb() + self.__hexp = BooleanVar() + self.__hexp.set(optiondb.get('HEXTYPE', 0)) + self.__uwtyping = BooleanVar() + self.__uwtyping.set(optiondb.get('UPWHILETYPE', 0)) + # create the gui + self.__frame = Frame(master, relief=RAISED, borderwidth=1) + self.__frame.grid(row=3, column=1, sticky='NSEW') + # Red + self.__xl = Label(self.__frame, text='Red:') + self.__xl.grid(row=0, column=0, sticky=E) + subframe = Frame(self.__frame) + subframe.grid(row=0, column=1) + self.__xox = Label(subframe, text='0x') + self.__xox.grid(row=0, column=0, sticky=E) + self.__xox['font'] = 'courier' + self.__x = Entry(subframe, width=3) + self.__x.grid(row=0, column=1) + self.__x.bindtags(self.__x.bindtags() + ('Normalize', 'Update')) + self.__x.bind_class('Normalize', '', self.__normalize) + self.__x.bind_class('Update' , '', self.__maybeupdate) + # Green + self.__yl = Label(self.__frame, text='Green:') + self.__yl.grid(row=1, column=0, sticky=E) + subframe = Frame(self.__frame) + subframe.grid(row=1, column=1) + self.__yox = Label(subframe, text='0x') + self.__yox.grid(row=0, column=0, sticky=E) + self.__yox['font'] = 'courier' + self.__y = Entry(subframe, width=3) + self.__y.grid(row=0, column=1) + self.__y.bindtags(self.__y.bindtags() + ('Normalize', 'Update')) + # Blue + self.__zl = Label(self.__frame, text='Blue:') + self.__zl.grid(row=2, column=0, sticky=E) + subframe = Frame(self.__frame) + subframe.grid(row=2, column=1) + self.__zox = Label(subframe, text='0x') + self.__zox.grid(row=0, column=0, sticky=E) + self.__zox['font'] = 'courier' + self.__z = Entry(subframe, width=3) + self.__z.grid(row=0, column=1) + self.__z.bindtags(self.__z.bindtags() + ('Normalize', 'Update')) + # Update while typing? + self.__uwt = Checkbutton(self.__frame, + text='Update while typing', + variable=self.__uwtyping) + self.__uwt.grid(row=3, column=0, columnspan=2, sticky=W) + # Hex/Dec + self.__hex = Checkbutton(self.__frame, + text='Hexadecimal', + variable=self.__hexp, + command=self.__togglehex) + self.__hex.grid(row=4, column=0, columnspan=2, sticky=W) + + def __togglehex(self, event=None): + red, green, blue = self.__sb.current_rgb() + if self.__hexp.get(): + label = '0x' + else: + label = ' ' + self.__xox['text'] = label + self.__yox['text'] = label + self.__zox['text'] = label + self.update_yourself(red, green, blue) + + def __normalize(self, event=None): + ew = event.widget + contents = ew.get() + icursor = ew.index(INSERT) + if contents and contents[0] in 'xX' and self.__hexp.get(): + contents = '0' + contents + # Figure out the contents in the current base. + try: + if self.__hexp.get(): + v = int(contents, 16) + else: + v = int(contents) + except ValueError: + v = None + # If value is not legal, or empty, delete the last character inserted + # and ring the bell. Don't ring the bell if the field is empty (it'll + # just equal zero. + if v is None: + pass + elif v < 0 or v > 255: + i = ew.index(INSERT) + if event.char: + contents = contents[:i-1] + contents[i:] + icursor -= 1 + ew.bell() + elif self.__hexp.get(): + contents = hex(v)[2:] + else: + contents = int(v) + ew.delete(0, END) + ew.insert(0, contents) + ew.icursor(icursor) + + def __maybeupdate(self, event=None): + if self.__uwtyping.get() or event.keysym in ('Return', 'Tab'): + self.__update(event) + + def __update(self, event=None): + redstr = self.__x.get() or '0' + greenstr = self.__y.get() or '0' + bluestr = self.__z.get() or '0' + if self.__hexp.get(): + base = 16 + else: + base = 10 + red, green, blue = [int(x, base) for x in (redstr, greenstr, bluestr)] + self.__sb.update_views(red, green, blue) + + def update_yourself(self, red, green, blue): + if self.__hexp.get(): + sred, sgreen, sblue = [hex(x)[2:] for x in (red, green, blue)] + else: + sred, sgreen, sblue = red, green, blue + x, y, z = self.__x, self.__y, self.__z + xicursor = x.index(INSERT) + yicursor = y.index(INSERT) + zicursor = z.index(INSERT) + x.delete(0, END) + y.delete(0, END) + z.delete(0, END) + x.insert(0, sred) + y.insert(0, sgreen) + z.insert(0, sblue) + x.icursor(xicursor) + y.icursor(yicursor) + z.icursor(zicursor) + + def hexp_var(self): + return self.__hexp + + def save_options(self, optiondb): + optiondb['HEXTYPE'] = self.__hexp.get() + optiondb['UPWHILETYPE'] = self.__uwtyping.get() diff --git a/marketing/Tools/pynche/X/rgb.txt b/marketing/Tools/pynche/X/rgb.txt new file mode 100644 index 0000000000000000000000000000000000000000..b11ffd058cb96c0f113ffceaa0ef60725fc03c4e --- /dev/null +++ b/marketing/Tools/pynche/X/rgb.txt @@ -0,0 +1,753 @@ +! $XConsortium: rgb.txt,v 10.41 94/02/20 18:39:36 rws Exp $ +255 250 250 snow +248 248 255 ghost white +248 248 255 GhostWhite +245 245 245 white smoke +245 245 245 WhiteSmoke +220 220 220 gainsboro +255 250 240 floral white +255 250 240 FloralWhite +253 245 230 old lace +253 245 230 OldLace +250 240 230 linen +250 235 215 antique white +250 235 215 AntiqueWhite +255 239 213 papaya whip +255 239 213 PapayaWhip +255 235 205 blanched almond +255 235 205 BlanchedAlmond +255 228 196 bisque +255 218 185 peach puff +255 218 185 PeachPuff +255 222 173 navajo white +255 222 173 NavajoWhite +255 228 181 moccasin +255 248 220 cornsilk +255 255 240 ivory +255 250 205 lemon chiffon +255 250 205 LemonChiffon +255 245 238 seashell +240 255 240 honeydew +245 255 250 mint cream +245 255 250 MintCream +240 255 255 azure +240 248 255 alice blue +240 248 255 AliceBlue +230 230 250 lavender +255 240 245 lavender blush +255 240 245 LavenderBlush +255 228 225 misty rose +255 228 225 MistyRose +255 255 255 white + 0 0 0 black + 47 79 79 dark slate gray + 47 79 79 DarkSlateGray + 47 79 79 dark slate grey + 47 79 79 DarkSlateGrey +105 105 105 dim gray +105 105 105 DimGray +105 105 105 dim grey +105 105 105 DimGrey +112 128 144 slate gray +112 128 144 SlateGray +112 128 144 slate grey +112 128 144 SlateGrey +119 136 153 light slate gray +119 136 153 LightSlateGray +119 136 153 light slate grey +119 136 153 LightSlateGrey +190 190 190 gray +190 190 190 grey +211 211 211 light grey +211 211 211 LightGrey +211 211 211 light gray +211 211 211 LightGray + 25 25 112 midnight blue + 25 25 112 MidnightBlue + 0 0 128 navy + 0 0 128 navy blue + 0 0 128 NavyBlue +100 149 237 cornflower blue +100 149 237 CornflowerBlue + 72 61 139 dark slate blue + 72 61 139 DarkSlateBlue +106 90 205 slate blue +106 90 205 SlateBlue +123 104 238 medium slate blue +123 104 238 MediumSlateBlue +132 112 255 light slate blue +132 112 255 LightSlateBlue + 0 0 205 medium blue + 0 0 205 MediumBlue + 65 105 225 royal blue + 65 105 225 RoyalBlue + 0 0 255 blue + 30 144 255 dodger blue + 30 144 255 DodgerBlue + 0 191 255 deep sky blue + 0 191 255 DeepSkyBlue +135 206 235 sky blue +135 206 235 SkyBlue +135 206 250 light sky blue +135 206 250 LightSkyBlue + 70 130 180 steel blue + 70 130 180 SteelBlue +176 196 222 light steel blue +176 196 222 LightSteelBlue +173 216 230 light blue +173 216 230 LightBlue +176 224 230 powder blue +176 224 230 PowderBlue +175 238 238 pale turquoise +175 238 238 PaleTurquoise + 0 206 209 dark turquoise + 0 206 209 DarkTurquoise + 72 209 204 medium turquoise + 72 209 204 MediumTurquoise + 64 224 208 turquoise + 0 255 255 cyan +224 255 255 light cyan +224 255 255 LightCyan + 95 158 160 cadet blue + 95 158 160 CadetBlue +102 205 170 medium aquamarine +102 205 170 MediumAquamarine +127 255 212 aquamarine + 0 100 0 dark green + 0 100 0 DarkGreen + 85 107 47 dark olive green + 85 107 47 DarkOliveGreen +143 188 143 dark sea green +143 188 143 DarkSeaGreen + 46 139 87 sea green + 46 139 87 SeaGreen + 60 179 113 medium sea green + 60 179 113 MediumSeaGreen + 32 178 170 light sea green + 32 178 170 LightSeaGreen +152 251 152 pale green +152 251 152 PaleGreen + 0 255 127 spring green + 0 255 127 SpringGreen +124 252 0 lawn green +124 252 0 LawnGreen + 0 255 0 green +127 255 0 chartreuse + 0 250 154 medium spring green + 0 250 154 MediumSpringGreen +173 255 47 green yellow +173 255 47 GreenYellow + 50 205 50 lime green + 50 205 50 LimeGreen +154 205 50 yellow green +154 205 50 YellowGreen + 34 139 34 forest green + 34 139 34 ForestGreen +107 142 35 olive drab +107 142 35 OliveDrab +189 183 107 dark khaki +189 183 107 DarkKhaki +240 230 140 khaki +238 232 170 pale goldenrod +238 232 170 PaleGoldenrod +250 250 210 light goldenrod yellow +250 250 210 LightGoldenrodYellow +255 255 224 light yellow +255 255 224 LightYellow +255 255 0 yellow +255 215 0 gold +238 221 130 light goldenrod +238 221 130 LightGoldenrod +218 165 32 goldenrod +184 134 11 dark goldenrod +184 134 11 DarkGoldenrod +188 143 143 rosy brown +188 143 143 RosyBrown +205 92 92 indian red +205 92 92 IndianRed +139 69 19 saddle brown +139 69 19 SaddleBrown +160 82 45 sienna +205 133 63 peru +222 184 135 burlywood +245 245 220 beige +245 222 179 wheat +244 164 96 sandy brown +244 164 96 SandyBrown +210 180 140 tan +210 105 30 chocolate +178 34 34 firebrick +165 42 42 brown +233 150 122 dark salmon +233 150 122 DarkSalmon +250 128 114 salmon +255 160 122 light salmon +255 160 122 LightSalmon +255 165 0 orange +255 140 0 dark orange +255 140 0 DarkOrange +255 127 80 coral +240 128 128 light coral +240 128 128 LightCoral +255 99 71 tomato +255 69 0 orange red +255 69 0 OrangeRed +255 0 0 red +255 105 180 hot pink +255 105 180 HotPink +255 20 147 deep pink +255 20 147 DeepPink +255 192 203 pink +255 182 193 light pink +255 182 193 LightPink +219 112 147 pale violet red +219 112 147 PaleVioletRed +176 48 96 maroon +199 21 133 medium violet red +199 21 133 MediumVioletRed +208 32 144 violet red +208 32 144 VioletRed +255 0 255 magenta +238 130 238 violet +221 160 221 plum +218 112 214 orchid +186 85 211 medium orchid +186 85 211 MediumOrchid +153 50 204 dark orchid +153 50 204 DarkOrchid +148 0 211 dark violet +148 0 211 DarkViolet +138 43 226 blue violet +138 43 226 BlueViolet +160 32 240 purple +147 112 219 medium purple +147 112 219 MediumPurple +216 191 216 thistle +255 250 250 snow1 +238 233 233 snow2 +205 201 201 snow3 +139 137 137 snow4 +255 245 238 seashell1 +238 229 222 seashell2 +205 197 191 seashell3 +139 134 130 seashell4 +255 239 219 AntiqueWhite1 +238 223 204 AntiqueWhite2 +205 192 176 AntiqueWhite3 +139 131 120 AntiqueWhite4 +255 228 196 bisque1 +238 213 183 bisque2 +205 183 158 bisque3 +139 125 107 bisque4 +255 218 185 PeachPuff1 +238 203 173 PeachPuff2 +205 175 149 PeachPuff3 +139 119 101 PeachPuff4 +255 222 173 NavajoWhite1 +238 207 161 NavajoWhite2 +205 179 139 NavajoWhite3 +139 121 94 NavajoWhite4 +255 250 205 LemonChiffon1 +238 233 191 LemonChiffon2 +205 201 165 LemonChiffon3 +139 137 112 LemonChiffon4 +255 248 220 cornsilk1 +238 232 205 cornsilk2 +205 200 177 cornsilk3 +139 136 120 cornsilk4 +255 255 240 ivory1 +238 238 224 ivory2 +205 205 193 ivory3 +139 139 131 ivory4 +240 255 240 honeydew1 +224 238 224 honeydew2 +193 205 193 honeydew3 +131 139 131 honeydew4 +255 240 245 LavenderBlush1 +238 224 229 LavenderBlush2 +205 193 197 LavenderBlush3 +139 131 134 LavenderBlush4 +255 228 225 MistyRose1 +238 213 210 MistyRose2 +205 183 181 MistyRose3 +139 125 123 MistyRose4 +240 255 255 azure1 +224 238 238 azure2 +193 205 205 azure3 +131 139 139 azure4 +131 111 255 SlateBlue1 +122 103 238 SlateBlue2 +105 89 205 SlateBlue3 + 71 60 139 SlateBlue4 + 72 118 255 RoyalBlue1 + 67 110 238 RoyalBlue2 + 58 95 205 RoyalBlue3 + 39 64 139 RoyalBlue4 + 0 0 255 blue1 + 0 0 238 blue2 + 0 0 205 blue3 + 0 0 139 blue4 + 30 144 255 DodgerBlue1 + 28 134 238 DodgerBlue2 + 24 116 205 DodgerBlue3 + 16 78 139 DodgerBlue4 + 99 184 255 SteelBlue1 + 92 172 238 SteelBlue2 + 79 148 205 SteelBlue3 + 54 100 139 SteelBlue4 + 0 191 255 DeepSkyBlue1 + 0 178 238 DeepSkyBlue2 + 0 154 205 DeepSkyBlue3 + 0 104 139 DeepSkyBlue4 +135 206 255 SkyBlue1 +126 192 238 SkyBlue2 +108 166 205 SkyBlue3 + 74 112 139 SkyBlue4 +176 226 255 LightSkyBlue1 +164 211 238 LightSkyBlue2 +141 182 205 LightSkyBlue3 + 96 123 139 LightSkyBlue4 +198 226 255 SlateGray1 +185 211 238 SlateGray2 +159 182 205 SlateGray3 +108 123 139 SlateGray4 +202 225 255 LightSteelBlue1 +188 210 238 LightSteelBlue2 +162 181 205 LightSteelBlue3 +110 123 139 LightSteelBlue4 +191 239 255 LightBlue1 +178 223 238 LightBlue2 +154 192 205 LightBlue3 +104 131 139 LightBlue4 +224 255 255 LightCyan1 +209 238 238 LightCyan2 +180 205 205 LightCyan3 +122 139 139 LightCyan4 +187 255 255 PaleTurquoise1 +174 238 238 PaleTurquoise2 +150 205 205 PaleTurquoise3 +102 139 139 PaleTurquoise4 +152 245 255 CadetBlue1 +142 229 238 CadetBlue2 +122 197 205 CadetBlue3 + 83 134 139 CadetBlue4 + 0 245 255 turquoise1 + 0 229 238 turquoise2 + 0 197 205 turquoise3 + 0 134 139 turquoise4 + 0 255 255 cyan1 + 0 238 238 cyan2 + 0 205 205 cyan3 + 0 139 139 cyan4 +151 255 255 DarkSlateGray1 +141 238 238 DarkSlateGray2 +121 205 205 DarkSlateGray3 + 82 139 139 DarkSlateGray4 +127 255 212 aquamarine1 +118 238 198 aquamarine2 +102 205 170 aquamarine3 + 69 139 116 aquamarine4 +193 255 193 DarkSeaGreen1 +180 238 180 DarkSeaGreen2 +155 205 155 DarkSeaGreen3 +105 139 105 DarkSeaGreen4 + 84 255 159 SeaGreen1 + 78 238 148 SeaGreen2 + 67 205 128 SeaGreen3 + 46 139 87 SeaGreen4 +154 255 154 PaleGreen1 +144 238 144 PaleGreen2 +124 205 124 PaleGreen3 + 84 139 84 PaleGreen4 + 0 255 127 SpringGreen1 + 0 238 118 SpringGreen2 + 0 205 102 SpringGreen3 + 0 139 69 SpringGreen4 + 0 255 0 green1 + 0 238 0 green2 + 0 205 0 green3 + 0 139 0 green4 +127 255 0 chartreuse1 +118 238 0 chartreuse2 +102 205 0 chartreuse3 + 69 139 0 chartreuse4 +192 255 62 OliveDrab1 +179 238 58 OliveDrab2 +154 205 50 OliveDrab3 +105 139 34 OliveDrab4 +202 255 112 DarkOliveGreen1 +188 238 104 DarkOliveGreen2 +162 205 90 DarkOliveGreen3 +110 139 61 DarkOliveGreen4 +255 246 143 khaki1 +238 230 133 khaki2 +205 198 115 khaki3 +139 134 78 khaki4 +255 236 139 LightGoldenrod1 +238 220 130 LightGoldenrod2 +205 190 112 LightGoldenrod3 +139 129 76 LightGoldenrod4 +255 255 224 LightYellow1 +238 238 209 LightYellow2 +205 205 180 LightYellow3 +139 139 122 LightYellow4 +255 255 0 yellow1 +238 238 0 yellow2 +205 205 0 yellow3 +139 139 0 yellow4 +255 215 0 gold1 +238 201 0 gold2 +205 173 0 gold3 +139 117 0 gold4 +255 193 37 goldenrod1 +238 180 34 goldenrod2 +205 155 29 goldenrod3 +139 105 20 goldenrod4 +255 185 15 DarkGoldenrod1 +238 173 14 DarkGoldenrod2 +205 149 12 DarkGoldenrod3 +139 101 8 DarkGoldenrod4 +255 193 193 RosyBrown1 +238 180 180 RosyBrown2 +205 155 155 RosyBrown3 +139 105 105 RosyBrown4 +255 106 106 IndianRed1 +238 99 99 IndianRed2 +205 85 85 IndianRed3 +139 58 58 IndianRed4 +255 130 71 sienna1 +238 121 66 sienna2 +205 104 57 sienna3 +139 71 38 sienna4 +255 211 155 burlywood1 +238 197 145 burlywood2 +205 170 125 burlywood3 +139 115 85 burlywood4 +255 231 186 wheat1 +238 216 174 wheat2 +205 186 150 wheat3 +139 126 102 wheat4 +255 165 79 tan1 +238 154 73 tan2 +205 133 63 tan3 +139 90 43 tan4 +255 127 36 chocolate1 +238 118 33 chocolate2 +205 102 29 chocolate3 +139 69 19 chocolate4 +255 48 48 firebrick1 +238 44 44 firebrick2 +205 38 38 firebrick3 +139 26 26 firebrick4 +255 64 64 brown1 +238 59 59 brown2 +205 51 51 brown3 +139 35 35 brown4 +255 140 105 salmon1 +238 130 98 salmon2 +205 112 84 salmon3 +139 76 57 salmon4 +255 160 122 LightSalmon1 +238 149 114 LightSalmon2 +205 129 98 LightSalmon3 +139 87 66 LightSalmon4 +255 165 0 orange1 +238 154 0 orange2 +205 133 0 orange3 +139 90 0 orange4 +255 127 0 DarkOrange1 +238 118 0 DarkOrange2 +205 102 0 DarkOrange3 +139 69 0 DarkOrange4 +255 114 86 coral1 +238 106 80 coral2 +205 91 69 coral3 +139 62 47 coral4 +255 99 71 tomato1 +238 92 66 tomato2 +205 79 57 tomato3 +139 54 38 tomato4 +255 69 0 OrangeRed1 +238 64 0 OrangeRed2 +205 55 0 OrangeRed3 +139 37 0 OrangeRed4 +255 0 0 red1 +238 0 0 red2 +205 0 0 red3 +139 0 0 red4 +255 20 147 DeepPink1 +238 18 137 DeepPink2 +205 16 118 DeepPink3 +139 10 80 DeepPink4 +255 110 180 HotPink1 +238 106 167 HotPink2 +205 96 144 HotPink3 +139 58 98 HotPink4 +255 181 197 pink1 +238 169 184 pink2 +205 145 158 pink3 +139 99 108 pink4 +255 174 185 LightPink1 +238 162 173 LightPink2 +205 140 149 LightPink3 +139 95 101 LightPink4 +255 130 171 PaleVioletRed1 +238 121 159 PaleVioletRed2 +205 104 137 PaleVioletRed3 +139 71 93 PaleVioletRed4 +255 52 179 maroon1 +238 48 167 maroon2 +205 41 144 maroon3 +139 28 98 maroon4 +255 62 150 VioletRed1 +238 58 140 VioletRed2 +205 50 120 VioletRed3 +139 34 82 VioletRed4 +255 0 255 magenta1 +238 0 238 magenta2 +205 0 205 magenta3 +139 0 139 magenta4 +255 131 250 orchid1 +238 122 233 orchid2 +205 105 201 orchid3 +139 71 137 orchid4 +255 187 255 plum1 +238 174 238 plum2 +205 150 205 plum3 +139 102 139 plum4 +224 102 255 MediumOrchid1 +209 95 238 MediumOrchid2 +180 82 205 MediumOrchid3 +122 55 139 MediumOrchid4 +191 62 255 DarkOrchid1 +178 58 238 DarkOrchid2 +154 50 205 DarkOrchid3 +104 34 139 DarkOrchid4 +155 48 255 purple1 +145 44 238 purple2 +125 38 205 purple3 + 85 26 139 purple4 +171 130 255 MediumPurple1 +159 121 238 MediumPurple2 +137 104 205 MediumPurple3 + 93 71 139 MediumPurple4 +255 225 255 thistle1 +238 210 238 thistle2 +205 181 205 thistle3 +139 123 139 thistle4 + 0 0 0 gray0 + 0 0 0 grey0 + 3 3 3 gray1 + 3 3 3 grey1 + 5 5 5 gray2 + 5 5 5 grey2 + 8 8 8 gray3 + 8 8 8 grey3 + 10 10 10 gray4 + 10 10 10 grey4 + 13 13 13 gray5 + 13 13 13 grey5 + 15 15 15 gray6 + 15 15 15 grey6 + 18 18 18 gray7 + 18 18 18 grey7 + 20 20 20 gray8 + 20 20 20 grey8 + 23 23 23 gray9 + 23 23 23 grey9 + 26 26 26 gray10 + 26 26 26 grey10 + 28 28 28 gray11 + 28 28 28 grey11 + 31 31 31 gray12 + 31 31 31 grey12 + 33 33 33 gray13 + 33 33 33 grey13 + 36 36 36 gray14 + 36 36 36 grey14 + 38 38 38 gray15 + 38 38 38 grey15 + 41 41 41 gray16 + 41 41 41 grey16 + 43 43 43 gray17 + 43 43 43 grey17 + 46 46 46 gray18 + 46 46 46 grey18 + 48 48 48 gray19 + 48 48 48 grey19 + 51 51 51 gray20 + 51 51 51 grey20 + 54 54 54 gray21 + 54 54 54 grey21 + 56 56 56 gray22 + 56 56 56 grey22 + 59 59 59 gray23 + 59 59 59 grey23 + 61 61 61 gray24 + 61 61 61 grey24 + 64 64 64 gray25 + 64 64 64 grey25 + 66 66 66 gray26 + 66 66 66 grey26 + 69 69 69 gray27 + 69 69 69 grey27 + 71 71 71 gray28 + 71 71 71 grey28 + 74 74 74 gray29 + 74 74 74 grey29 + 77 77 77 gray30 + 77 77 77 grey30 + 79 79 79 gray31 + 79 79 79 grey31 + 82 82 82 gray32 + 82 82 82 grey32 + 84 84 84 gray33 + 84 84 84 grey33 + 87 87 87 gray34 + 87 87 87 grey34 + 89 89 89 gray35 + 89 89 89 grey35 + 92 92 92 gray36 + 92 92 92 grey36 + 94 94 94 gray37 + 94 94 94 grey37 + 97 97 97 gray38 + 97 97 97 grey38 + 99 99 99 gray39 + 99 99 99 grey39 +102 102 102 gray40 +102 102 102 grey40 +105 105 105 gray41 +105 105 105 grey41 +107 107 107 gray42 +107 107 107 grey42 +110 110 110 gray43 +110 110 110 grey43 +112 112 112 gray44 +112 112 112 grey44 +115 115 115 gray45 +115 115 115 grey45 +117 117 117 gray46 +117 117 117 grey46 +120 120 120 gray47 +120 120 120 grey47 +122 122 122 gray48 +122 122 122 grey48 +125 125 125 gray49 +125 125 125 grey49 +127 127 127 gray50 +127 127 127 grey50 +130 130 130 gray51 +130 130 130 grey51 +133 133 133 gray52 +133 133 133 grey52 +135 135 135 gray53 +135 135 135 grey53 +138 138 138 gray54 +138 138 138 grey54 +140 140 140 gray55 +140 140 140 grey55 +143 143 143 gray56 +143 143 143 grey56 +145 145 145 gray57 +145 145 145 grey57 +148 148 148 gray58 +148 148 148 grey58 +150 150 150 gray59 +150 150 150 grey59 +153 153 153 gray60 +153 153 153 grey60 +156 156 156 gray61 +156 156 156 grey61 +158 158 158 gray62 +158 158 158 grey62 +161 161 161 gray63 +161 161 161 grey63 +163 163 163 gray64 +163 163 163 grey64 +166 166 166 gray65 +166 166 166 grey65 +168 168 168 gray66 +168 168 168 grey66 +171 171 171 gray67 +171 171 171 grey67 +173 173 173 gray68 +173 173 173 grey68 +176 176 176 gray69 +176 176 176 grey69 +179 179 179 gray70 +179 179 179 grey70 +181 181 181 gray71 +181 181 181 grey71 +184 184 184 gray72 +184 184 184 grey72 +186 186 186 gray73 +186 186 186 grey73 +189 189 189 gray74 +189 189 189 grey74 +191 191 191 gray75 +191 191 191 grey75 +194 194 194 gray76 +194 194 194 grey76 +196 196 196 gray77 +196 196 196 grey77 +199 199 199 gray78 +199 199 199 grey78 +201 201 201 gray79 +201 201 201 grey79 +204 204 204 gray80 +204 204 204 grey80 +207 207 207 gray81 +207 207 207 grey81 +209 209 209 gray82 +209 209 209 grey82 +212 212 212 gray83 +212 212 212 grey83 +214 214 214 gray84 +214 214 214 grey84 +217 217 217 gray85 +217 217 217 grey85 +219 219 219 gray86 +219 219 219 grey86 +222 222 222 gray87 +222 222 222 grey87 +224 224 224 gray88 +224 224 224 grey88 +227 227 227 gray89 +227 227 227 grey89 +229 229 229 gray90 +229 229 229 grey90 +232 232 232 gray91 +232 232 232 grey91 +235 235 235 gray92 +235 235 235 grey92 +237 237 237 gray93 +237 237 237 grey93 +240 240 240 gray94 +240 240 240 grey94 +242 242 242 gray95 +242 242 242 grey95 +245 245 245 gray96 +245 245 245 grey96 +247 247 247 gray97 +247 247 247 grey97 +250 250 250 gray98 +250 250 250 grey98 +252 252 252 gray99 +252 252 252 grey99 +255 255 255 gray100 +255 255 255 grey100 +169 169 169 dark grey +169 169 169 DarkGrey +169 169 169 dark gray +169 169 169 DarkGray +0 0 139 dark blue +0 0 139 DarkBlue +0 139 139 dark cyan +0 139 139 DarkCyan +139 0 139 dark magenta +139 0 139 DarkMagenta +139 0 0 dark red +139 0 0 DarkRed +144 238 144 light green +144 238 144 LightGreen diff --git a/marketing/Tools/pynche/X/xlicense.txt b/marketing/Tools/pynche/X/xlicense.txt new file mode 100644 index 0000000000000000000000000000000000000000..b4471db6753b479905e36099646f8b584a8f69eb --- /dev/null +++ b/marketing/Tools/pynche/X/xlicense.txt @@ -0,0 +1,29 @@ +X Window System License - X11R6.4 + +Copyright (c) 1998 The Open Group + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +X Window System is a trademark of The Open Group diff --git a/marketing/Tools/pynche/__init__.py b/marketing/Tools/pynche/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b93054b3ecf3a5af96f4772e7208e7a18b5dd4a4 --- /dev/null +++ b/marketing/Tools/pynche/__init__.py @@ -0,0 +1 @@ +# Dummy file to make this directory a package. diff --git a/marketing/Tools/pynche/__pycache__/ChipViewer.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/ChipViewer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e71e2788519213716de4c47b4b109b4244409de Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/ChipViewer.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/ColorDB.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/ColorDB.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0bf264c1fba80fc72e2543c75272d8bc066fa014 Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/ColorDB.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/DetailsViewer.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/DetailsViewer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25c1cfb973df3427a382dde3113608b16270bf58 Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/DetailsViewer.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/ListViewer.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/ListViewer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00afdb6d795dc5ce127c3842477ad9e6a63e9f0e Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/ListViewer.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/Main.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/Main.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7462df70fb816c750bec9a76b256f0f7fd40d20e Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/Main.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/PyncheWidget.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/PyncheWidget.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de883ff37d444023cf614a3079271774c2f88641 Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/PyncheWidget.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/StripViewer.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/StripViewer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5d87e6fcb1acf4bae7854e766bc862507af45a71 Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/StripViewer.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/Switchboard.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/Switchboard.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aae10853a334359c7fbf0e27eed938cb5372c618 Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/Switchboard.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/TextViewer.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/TextViewer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84d3600ee5f00ca1d961eca2734b6114a2973085 Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/TextViewer.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/TypeinViewer.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/TypeinViewer.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c552ce7a88406db777a614a21a767c7b90eebf9 Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/TypeinViewer.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/__init__.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..157cdf76c9769e8c8a61d9c6b9eefb42562ff56e Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/__init__.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/__pycache__/pyColorChooser.cpython-39.pyc b/marketing/Tools/pynche/__pycache__/pyColorChooser.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1005b7b898049a359de2e5a2147b4ca9931ecfd4 Binary files /dev/null and b/marketing/Tools/pynche/__pycache__/pyColorChooser.cpython-39.pyc differ diff --git a/marketing/Tools/pynche/html40colors.txt b/marketing/Tools/pynche/html40colors.txt new file mode 100644 index 0000000000000000000000000000000000000000..3eeb0a10a89f9aedc23c6dd6291db02ef1af6126 --- /dev/null +++ b/marketing/Tools/pynche/html40colors.txt @@ -0,0 +1,17 @@ +# HTML 4.0 color names +Black #000000 +Silver #c0c0c0 +Gray #808080 +White #ffffff +Maroon #800000 +Red #ff0000 +Purple #800080 +Fuchsia #ff00ff +Green #008000 +Lime #00ff00 +Olive #808000 +Yellow #ffff00 +Navy #000080 +Blue #0000ff +Teal #008080 +Aqua #00ffff diff --git a/marketing/Tools/pynche/namedcolors.txt b/marketing/Tools/pynche/namedcolors.txt new file mode 100644 index 0000000000000000000000000000000000000000..3658e85f25688763bd019373fbe789f1251c8fa6 --- /dev/null +++ b/marketing/Tools/pynche/namedcolors.txt @@ -0,0 +1,100 @@ +# named colors from http://www.lightlink.com/xine/bells/namedcolors.html +White #FFFFFF +Red #FF0000 +Green #00FF00 +Blue #0000FF +Magenta #FF00FF +Cyan #00FFFF +Yellow #FFFF00 +Black #000000 +Aquamarine #70DB93 +Baker's Chocolate #5C3317 +Blue Violet #9F5F9F +Brass #B5A642 +Bright Gold #D9D919 +Brown #A62A2A +Bronze #8C7853 +Bronze II #A67D3D +Cadet Blue #5F9F9F +Cool Copper #D98719 +Copper #B87333 +Coral #FF7F00 +Corn Flower Blue #42426F +Dark Brown #5C4033 +Dark Green #2F4F2F +Dark Green Copper #4A766E +Dark Olive Green #4F4F2F +Dark Orchid #9932CD +Dark Purple #871F78 +Dark Slate Blue #6B238E +Dark Slate Grey #2F4F4F +Dark Tan #97694F +Dark Turquoise #7093DB +Dark Wood #855E42 +Dim Grey #545454 +Dusty Rose #856363 +Feldspar #D19275 +Firebrick #8E2323 +Forest Green #238E23 +Gold #CD7F32 +Goldenrod #DBDB70 +Grey #C0C0C0 +Green Copper #527F76 +Green Yellow #93DB70 +Hunter Green #215E21 +Indian Red #4E2F2F +Khaki #9F9F5F +Light Blue #C0D9D9 +Light Grey #A8A8A8 +Light Steel Blue #8F8FBD +Light Wood #E9C2A6 +Lime Green #32CD32 +Mandarian Orange #E47833 +Maroon #8E236B +Medium Aquamarine #32CD99 +Medium Blue #3232CD +Medium Forest Green #6B8E23 +Medium Goldenrod #EAEAAE +Medium Orchid #9370DB +Medium Sea Green #426F42 +Medium Slate Blue #7F00FF +Medium Spring Green #7FFF00 +Medium Turquoise #70DBDB +Medium Violet Red #DB7093 +Medium Wood #A68064 +Midnight Blue #2F2F4F +Navy Blue #23238E +Neon Blue #4D4DFF +Neon Pink #FF6EC7 +New Midnight Blue #00009C +New Tan #EBC79E +Old Gold #CFB53B +Orange #FF7F00 +Orange Red #FF2400 +Orchid #DB70DB +Pale Green #8FBC8F +Pink #BC8F8F +Plum #EAADEA +Quartz #D9D9F3 +Rich Blue #5959AB +Salmon #6F4242 +Scarlet #8C1717 +Sea Green #238E68 +Semi-Sweet Chocolate #6B4226 +Sienna #8E6B23 +Silver #E6E8FA +Sky Blue #3299CC +Slate Blue #007FFF +Spicy Pink #FF1CAE +Spring Green #00FF7F +Steel Blue #236B8E +Summer Sky #38B0DE +Tan #DB9370 +Thistle #D8BFD8 +Turquoise #ADEAEA +Very Dark Brown #5C4033 +Very Light Grey #CDCDCD +Violet #4F2F4F +Violet Red #CC3299 +Wheat #D8D8BF +Yellow Green #99CC32 diff --git a/marketing/Tools/pynche/pyColorChooser.py b/marketing/Tools/pynche/pyColorChooser.py new file mode 100644 index 0000000000000000000000000000000000000000..3286047a5fc8b087f963f543f2c1db5aab04b63c --- /dev/null +++ b/marketing/Tools/pynche/pyColorChooser.py @@ -0,0 +1,125 @@ +"""Color chooser implementing (almost) the tkColorColor interface +""" + +import os +import Main +import ColorDB + + + +class Chooser: + """Ask for a color""" + def __init__(self, + master = None, + databasefile = None, + initfile = None, + ignore = None, + wantspec = None): + self.__master = master + self.__databasefile = databasefile + self.__initfile = initfile or os.path.expanduser('~/.pynche') + self.__ignore = ignore + self.__pw = None + self.__wantspec = wantspec + + def show(self, color, options): + # scan for options that can override the ctor options + self.__wantspec = options.get('wantspec', self.__wantspec) + dbfile = options.get('databasefile', self.__databasefile) + # load the database file + colordb = None + if dbfile != self.__databasefile: + colordb = ColorDB.get_colordb(dbfile) + if not self.__master: + from tkinter import Tk + self.__master = Tk() + if not self.__pw: + self.__pw, self.__sb = \ + Main.build(master = self.__master, + initfile = self.__initfile, + ignore = self.__ignore) + else: + self.__pw.deiconify() + # convert color + if colordb: + self.__sb.set_colordb(colordb) + else: + colordb = self.__sb.colordb() + if color: + r, g, b = Main.initial_color(color, colordb) + self.__sb.update_views(r, g, b) + # reset the canceled flag and run it + self.__sb.canceled(0) + Main.run(self.__pw, self.__sb) + rgbtuple = self.__sb.current_rgb() + self.__pw.withdraw() + # check to see if the cancel button was pushed + if self.__sb.canceled_p(): + return None, None + # Try to return the color name from the database if there is an exact + # match, otherwise use the "#rrggbb" spec. BAW: Forget about color + # aliases for now, maybe later we should return these too. + name = None + if not self.__wantspec: + try: + name = colordb.find_byrgb(rgbtuple)[0] + except ColorDB.BadColor: + pass + if name is None: + name = ColorDB.triplet_to_rrggbb(rgbtuple) + return rgbtuple, name + + def save(self): + if self.__sb: + self.__sb.save_views() + + +# convenience stuff +_chooser = None + +def askcolor(color = None, **options): + """Ask for a color""" + global _chooser + if not _chooser: + _chooser = Chooser(**options) + return _chooser.show(color, options) + +def save(): + global _chooser + if _chooser: + _chooser.save() + + +# test stuff +if __name__ == '__main__': + from tkinter import * + + class Tester: + def __init__(self): + self.__root = tk = Tk() + b = Button(tk, text='Choose Color...', command=self.__choose) + b.pack() + self.__l = Label(tk) + self.__l.pack() + q = Button(tk, text='Quit', command=self.__quit) + q.pack() + + def __choose(self, event=None): + rgb, name = askcolor(master=self.__root) + if rgb is None: + text = 'You hit CANCEL!' + else: + r, g, b = rgb + text = 'You picked %s (%3d/%3d/%3d)' % (name, r, g, b) + self.__l.configure(text=text) + + def __quit(self, event=None): + self.__root.quit() + + def run(self): + self.__root.mainloop() + t = Tester() + t.run() + # simpler +## print 'color:', askcolor() +## print 'color:', askcolor() diff --git a/marketing/Tools/pynche/pynche.pyw b/marketing/Tools/pynche/pynche.pyw new file mode 100644 index 0000000000000000000000000000000000000000..6dfc8fed715fed209f725addc4eb633116e0ca91 --- /dev/null +++ b/marketing/Tools/pynche/pynche.pyw @@ -0,0 +1,7 @@ +#! /usr/bin/env python + +"""Run this file under Windows to inhibit the console window. +Run the file pynche.py under Unix or when debugging under Windows. +""" +import Main +Main.main() diff --git a/marketing/Tools/pynche/webcolors.txt b/marketing/Tools/pynche/webcolors.txt new file mode 100644 index 0000000000000000000000000000000000000000..f645c1e6106424b950f1c84baed6677232550605 --- /dev/null +++ b/marketing/Tools/pynche/webcolors.txt @@ -0,0 +1,141 @@ +# De-facto NS & MSIE recognized HTML color names +AliceBlue #f0f8ff +AntiqueWhite #faebd7 +Aqua #00ffff +Aquamarine #7fffd4 +Azure #f0ffff +Beige #f5f5dc +Bisque #ffe4c4 +Black #000000 +BlanchedAlmond #ffebcd +Blue #0000ff +BlueViolet #8a2be2 +Brown #a52a2a +BurlyWood #deb887 +CadetBlue #5f9ea0 +Chartreuse #7fff00 +Chocolate #d2691e +Coral #ff7f50 +CornflowerBlue #6495ed +Cornsilk #fff8dc +Crimson #dc143c +Cyan #00ffff +DarkBlue #00008b +DarkCyan #008b8b +DarkGoldenrod #b8860b +DarkGray #a9a9a9 +DarkGreen #006400 +DarkKhaki #bdb76b +DarkMagenta #8b008b +DarkOliveGreen #556b2f +DarkOrange #ff8c00 +DarkOrchid #9932cc +DarkRed #8b0000 +DarkSalmon #e9967a +DarkSeaGreen #8fbc8f +DarkSlateBlue #483d8b +DarkSlateGray #2f4f4f +DarkTurquoise #00ced1 +DarkViolet #9400d3 +DeepPink #ff1493 +DeepSkyBlue #00bfff +DimGray #696969 +DodgerBlue #1e90ff +FireBrick #b22222 +FloralWhite #fffaf0 +ForestGreen #228b22 +Fuchsia #ff00ff +Gainsboro #dcdcdc +GhostWhite #f8f8ff +Gold #ffd700 +Goldenrod #daa520 +Gray #808080 +Green #008000 +GreenYellow #adff2f +Honeydew #f0fff0 +HotPink #ff69b4 +IndianRed #cd5c5c +Indigo #4b0082 +Ivory #fffff0 +Khaki #f0e68c +Lavender #e6e6fa +LavenderBlush #fff0f5 +LawnGreen #7cfc00 +LemonChiffon #fffacd +LightBlue #add8e6 +LightCoral #f08080 +LightCyan #e0ffff +LightGoldenrodYellow #fafad2 +LightGreen #90ee90 +LightGrey #d3d3d3 +LightPink #ffb6c1 +LightSalmon #ffa07a +LightSeaGreen #20b2aa +LightSkyBlue #87cefa +LightSlateGray #778899 +LightSteelBlue #b0c4de +LightYellow #ffffe0 +Lime #00ff00 +LimeGreen #32cd32 +Linen #faf0e6 +Magenta #ff00ff +Maroon #800000 +MediumAquamarine #66cdaa +MediumBlue #0000cd +MediumOrchid #ba55d3 +MediumPurple #9370db +MediumSeaGreen #3cb371 +MediumSlateBlue #7b68ee +MediumSpringGreen #00fa9a +MediumTurquoise #48d1cc +MediumVioletRed #c71585 +MidnightBlue #191970 +MintCream #f5fffa +MistyRose #ffe4e1 +Moccasin #ffe4b5 +NavajoWhite #ffdead +Navy #000080 +OldLace #fdf5e6 +Olive #808000 +OliveDrab #6b8e23 +Orange #ffa500 +OrangeRed #ff4500 +Orchid #da70d6 +PaleGoldenrod #eee8aa +PaleGreen #98fb98 +PaleTurquoise #afeeee +PaleVioletRed #db7093 +PapayaWhip #ffefd5 +PeachPuff #ffdab9 +Peru #cd853f +Pink #ffc0cb +Plum #dda0dd +PowderBlue #b0e0e6 +Purple #800080 +Red #ff0000 +RosyBrown #bc8f8f +RoyalBlue #4169e1 +SaddleBrown #8b4513 +Salmon #fa8072 +SandyBrown #f4a460 +SeaGreen #2e8b57 +Seashell #fff5ee +Sienna #a0522d +Silver #c0c0c0 +SkyBlue #87ceeb +SlateBlue #6a5acd +SlateGray #708090 +Snow #fffafa +SpringGreen #00ff7f +SteelBlue #4682b4 +Tan #d2b48c +Teal #008080 +Thistle #d8bfd8 +Tomato #ff6347 +Turquoise #40e0d0 +Violet #ee82ee +Wheat #f5deb3 +White #ffffff +WhiteSmoke #f5f5f5 +Yellow #ffff00 +YellowGreen #9acd32 diff --git a/marketing/Tools/pynche/websafe.txt b/marketing/Tools/pynche/websafe.txt new file mode 100644 index 0000000000000000000000000000000000000000..70ed51e6832432eb79aa18f03998e0fd40741f5c --- /dev/null +++ b/marketing/Tools/pynche/websafe.txt @@ -0,0 +1,217 @@ +# Websafe RGB values +#000000 +#000033 +#000066 +#000099 +#0000cc +#0000ff +#003300 +#003333 +#003366 +#003399 +#0033cc +#0033ff +#006600 +#006633 +#006666 +#006699 +#0066cc +#0066ff +#009900 +#009933 +#009966 +#009999 +#0099cc +#0099ff +#00cc00 +#00cc33 +#00cc66 +#00cc99 +#00cccc +#00ccff +#00ff00 +#00ff33 +#00ff66 +#00ff99 +#00ffcc +#00ffff +#330000 +#330033 +#330066 +#330099 +#3300cc +#3300ff +#333300 +#333333 +#333366 +#333399 +#3333cc +#3333ff +#336600 +#336633 +#336666 +#336699 +#3366cc +#3366ff +#339900 +#339933 +#339966 +#339999 +#3399cc +#3399ff +#33cc00 +#33cc33 +#33cc66 +#33cc99 +#33cccc +#33ccff +#33ff00 +#33ff33 +#33ff66 +#33ff99 +#33ffcc +#33ffff +#660000 +#660033 +#660066 +#660099 +#6600cc +#6600ff +#663300 +#663333 +#663366 +#663399 +#6633cc +#6633ff +#666600 +#666633 +#666666 +#666699 +#6666cc +#6666ff +#669900 +#669933 +#669966 +#669999 +#6699cc +#6699ff +#66cc00 +#66cc33 +#66cc66 +#66cc99 +#66cccc +#66ccff +#66ff00 +#66ff33 +#66ff66 +#66ff99 +#66ffcc +#66ffff +#990000 +#990033 +#990066 +#990099 +#9900cc +#9900ff +#993300 +#993333 +#993366 +#993399 +#9933cc +#9933ff +#996600 +#996633 +#996666 +#996699 +#9966cc +#9966ff +#999900 +#999933 +#999966 +#999999 +#9999cc +#9999ff +#99cc00 +#99cc33 +#99cc66 +#99cc99 +#99cccc +#99ccff +#99ff00 +#99ff33 +#99ff66 +#99ff99 +#99ffcc +#99ffff +#cc0000 +#cc0033 +#cc0066 +#cc0099 +#cc00cc +#cc00ff +#cc3300 +#cc3333 +#cc3366 +#cc3399 +#cc33cc +#cc33ff +#cc6600 +#cc6633 +#cc6666 +#cc6699 +#cc66cc +#cc66ff +#cc9900 +#cc9933 +#cc9966 +#cc9999 +#cc99cc +#cc99ff +#cccc00 +#cccc33 +#cccc66 +#cccc99 +#cccccc +#ccccff +#ccff00 +#ccff33 +#ccff66 +#ccff99 +#ccffcc +#ccffff +#ff0000 +#ff0033 +#ff0066 +#ff0099 +#ff00cc +#ff00ff +#ff3300 +#ff3333 +#ff3366 +#ff3399 +#ff33cc +#ff33ff +#ff6600 +#ff6633 +#ff6666 +#ff6699 +#ff66cc +#ff66ff +#ff9900 +#ff9933 +#ff9966 +#ff9999 +#ff99cc +#ff99ff +#ffcc00 +#ffcc33 +#ffcc66 +#ffcc99 +#ffcccc +#ffccff +#ffff00 +#ffff33 +#ffff66 +#ffff99 +#ffffcc +#ffffff diff --git a/marketing/Tools/scripts/2to3.py b/marketing/Tools/scripts/2to3.py new file mode 100644 index 0000000000000000000000000000000000000000..fbd4aa6b838234014af3619fd3f4d8d9c999025d --- /dev/null +++ b/marketing/Tools/scripts/2to3.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python +import sys +from lib2to3.main import main + +sys.exit(main("lib2to3.fixes")) diff --git a/marketing/Tools/scripts/__pycache__/2to3.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/2to3.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a39985bf99489132fdabfddc9804d576cb8aa2e5 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/2to3.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/abitype.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/abitype.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e5ec784549aec5b799b6da0fda902b3a357bb48 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/abitype.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/analyze_dxp.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/analyze_dxp.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b2ca226b4275b2ea59da95fdd8472f41c5a3cc5 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/analyze_dxp.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/byext.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/byext.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b646c66cd1cf365ce61cdb8d15bee8294db79c30 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/byext.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/byteyears.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/byteyears.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eff66d7db7c5cdc5527d4b0e23f7ed8ec73c16db Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/byteyears.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/checkpip.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/checkpip.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1af365f47e9681a9cb22b3a081835298851d3720 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/checkpip.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/cleanfuture.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/cleanfuture.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3ae65f3e438063db197bf2568f23e393d50b4a7a Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/cleanfuture.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/combinerefs.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/combinerefs.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97e8860d6a1fd0a0998445964bc321ad4b07eac2 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/combinerefs.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/copytime.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/copytime.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..babee2845776709538591d987058e3fc43554df7 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/copytime.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/crlf.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/crlf.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd6bec25b6fb1a29a34c91db3d787c71cdd0a5a7 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/crlf.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/db2pickle.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/db2pickle.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2abffac8049a7ffd3c13fdbdd786e254cdb74cdb Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/db2pickle.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/diff.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/diff.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..89706f4b0c8cd5bcecf555f9b20c11a749c5b612 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/diff.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/dutree.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/dutree.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1be5ba746550a9d35b2661b43eaab010089272d2 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/dutree.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/eptags.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/eptags.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ea133ed54f2fc25ace30598f29e6ba82b34aad3 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/eptags.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/find-uname.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/find-uname.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1db09be2cbc83add33246978c3ec07309e87824f Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/find-uname.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/find_recursionlimit.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/find_recursionlimit.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..34322478ccdc9ba013a608e7a8f74398a1910fc2 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/find_recursionlimit.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/finddiv.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/finddiv.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d09b078648fba67f20da9ef5669e64d04b737f7 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/finddiv.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/findlinksto.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/findlinksto.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a620b17bd72567c153351215b4f08e5a2ca1da6 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/findlinksto.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/findnocoding.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/findnocoding.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4e18eea7b95e308521ab0697f4d85f49a8094d7 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/findnocoding.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/fixcid.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/fixcid.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f4bc63393fcfaf02037599ca2a79dfbed103604 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/fixcid.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/fixdiv.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/fixdiv.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ca776e6ff8dd945f2b7fcd0d3a60364548334c5a Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/fixdiv.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/fixheader.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/fixheader.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..037d76d2babf58ca08ecdaf7a5d9552bbf5de67e Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/fixheader.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/fixnotice.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/fixnotice.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..109bad30ada3c447dee927145073852ca8f68e76 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/fixnotice.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/fixps.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/fixps.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29305f88fb20e815f8329dc2aa2c1e4dc412006e Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/fixps.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/generate_opcode_h.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/generate_opcode_h.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd4e2df8e98a0d56575660cca6f5d8a161a89a46 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/generate_opcode_h.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/generate_symbol_py.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/generate_symbol_py.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..deb28bcaf320d71879953434a429bc2d5cb3f6c0 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/generate_symbol_py.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/generate_token.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/generate_token.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6964648cdcfedec2f304bc35680948e51238f0ce Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/generate_token.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/get-remote-certificate.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/get-remote-certificate.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..64c42b5fcc2b61ffe5ba1718f218ee05cde7237a Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/get-remote-certificate.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/google.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/google.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5252df349a29fc156356b0ffa5a017776fc2b540 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/google.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/gprof2html.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/gprof2html.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c93c0777d781a8e9797489c88f1c5fa58b42be3 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/gprof2html.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/highlight.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/highlight.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1662307c8745f34739a87399c7cc46db1e57c853 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/highlight.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/ifdef.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/ifdef.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efd0f30fc3c256a394c598b8b97b18b16b611c72 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/ifdef.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/import_diagnostics.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/import_diagnostics.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..044aae942c483022ad2290bf3cfcd15f5dd0602b Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/import_diagnostics.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/lfcr.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/lfcr.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aaeea9165490906a53e8d1c91c3c74160379ff1b Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/lfcr.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/linktree.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/linktree.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3caf7aa1bd2e4a084efe8bc89e30c0cf6d598ea Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/linktree.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/lll.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/lll.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a522b8a12d443624c6aff759c79c6785c0061d6d Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/lll.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/mailerdaemon.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/mailerdaemon.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2bcc10ed497754d71e82ea5f3c382e230507a47 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/mailerdaemon.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/make_ctype.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/make_ctype.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..88793f0e3de06f5be624b84249f40c65d50c95ed Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/make_ctype.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/md5sum.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/md5sum.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e433c07ae929bac5fab02ee15569ccaf27ff683 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/md5sum.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/mkreal.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/mkreal.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4da6dc235a48e5f471a97cc345526065509f86c2 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/mkreal.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/ndiff.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/ndiff.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af78d13f7eb86ad117f3d49007e56fbeb7bfd0be Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/ndiff.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/nm2def.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/nm2def.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..73a70e31979f975d93c33050a481ccded8235d8b Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/nm2def.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/objgraph.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/objgraph.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37b72a8561dc8970e2e195f422b2ad5f1b25b17c Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/objgraph.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/parse_html5_entities.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/parse_html5_entities.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21c2e79d1af1f9477940c5ab300170b93b545519 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/parse_html5_entities.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/parseentities.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/parseentities.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8b3195cc21c8ab20bbb473051b4d4aa54f848c01 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/parseentities.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/patchcheck.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/patchcheck.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..79d427672d7f2aa7a2fd61a15de9505011a0a8ca Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/patchcheck.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/pathfix.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/pathfix.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ca9f80f1f5e68622c0dcd45bc99d5c01d2755983 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/pathfix.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/pdeps.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/pdeps.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be4996377d075615f667a5ab0a205190a064e2d4 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/pdeps.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/pep384_macrocheck.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/pep384_macrocheck.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1996572d7bdd6a9785b4c45f54466ed6a649f384 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/pep384_macrocheck.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/pickle2db.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/pickle2db.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..526641f8cd27e078357a68f0cea78b212dd2f033 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/pickle2db.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/pindent.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/pindent.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1920873824d9a6766a3cccd6dbdc48851a8b0a6 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/pindent.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/ptags.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/ptags.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eed25bc2a79c2986f3c83c1633fa86de22f95fb2 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/ptags.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/pydoc3.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/pydoc3.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e43491685887c535d58a87c594e5a9061a6f5ae5 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/pydoc3.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/pysource.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/pysource.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c62f6f53ac53deef3fe914195a959e95a510951b Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/pysource.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/reindent-rst.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/reindent-rst.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c47c8bb35101a9c36f767a343d0fa5380ddfcd1 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/reindent-rst.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/reindent.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/reindent.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00c85bb5871487b1a8cf09d940576436fe7ffe80 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/reindent.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/rgrep.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/rgrep.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..88be2dadac077479c8a034aa59bb5b5aabf38932 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/rgrep.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/run_tests.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/run_tests.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ce71e2bd23eae7e8a31a9d39d37bc06e22a51a4 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/run_tests.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/serve.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/serve.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5308e80d4d4c61b6f0e02e94aad46cbe2a2e02a Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/serve.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/smelly.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/smelly.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d06eb59482072741ef59c494a160155e61f4c25d Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/smelly.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/suff.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/suff.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4f3f42902d96b258a32bbc4340356811a994e6b9 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/suff.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/texi2html.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/texi2html.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a294765ac388efc45201c2b90e644c0131e7fc8 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/texi2html.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/untabify.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/untabify.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9da7b89e17eac09eacd904bca41e0d20e41c2dbd Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/untabify.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/update_file.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/update_file.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..081f512ac717cfe04e96319f67f8189bcc8f975a Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/update_file.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/var_access_benchmark.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/var_access_benchmark.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..35b7e293f1193072206599354dd2284974a968a8 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/var_access_benchmark.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/verify_ensurepip_wheels.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/verify_ensurepip_wheels.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..34f1779b5ca41b6f058fa8e6c71cd5e117d11086 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/verify_ensurepip_wheels.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/which.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/which.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc7d67f5e05c7d2d761aaac6c9dbc70005d0a09e Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/which.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/__pycache__/win_add2path.cpython-39.pyc b/marketing/Tools/scripts/__pycache__/win_add2path.cpython-39.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8715546dbe7c409d6c5081b3408258c2adeda282 Binary files /dev/null and b/marketing/Tools/scripts/__pycache__/win_add2path.cpython-39.pyc differ diff --git a/marketing/Tools/scripts/abitype.py b/marketing/Tools/scripts/abitype.py new file mode 100644 index 0000000000000000000000000000000000000000..d6a74a1fe64117c4a44d60e6f55b77f77be58265 --- /dev/null +++ b/marketing/Tools/scripts/abitype.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 +# This script converts a C file to use the PEP 384 type definition API +# Usage: abitype.py < old_code > new_code +import re, sys + +###### Replacement of PyTypeObject static instances ############## + +# classify each token, giving it a one-letter code: +# S: static +# T: PyTypeObject +# I: ident +# W: whitespace +# =, {, }, ; : themselves +def classify(): + res = [] + for t,v in tokens: + if t == 'other' and v in "={};": + res.append(v) + elif t == 'ident': + if v == 'PyTypeObject': + res.append('T') + elif v == 'static': + res.append('S') + else: + res.append('I') + elif t == 'ws': + res.append('W') + else: + res.append('.') + return ''.join(res) + +# Obtain a list of fields of a PyTypeObject, in declaration order, +# skipping ob_base +# All comments are dropped from the variable (which are typically +# just the slot names, anyway), and information is discarded whether +# the original type was static. +def get_fields(start, real_end): + pos = start + # static? + if tokens[pos][1] == 'static': + pos += 2 + # PyTypeObject + pos += 2 + # name + name = tokens[pos][1] + pos += 1 + while tokens[pos][1] != '{': + pos += 1 + pos += 1 + # PyVarObject_HEAD_INIT + while tokens[pos][0] in ('ws', 'comment'): + pos += 1 + if tokens[pos][1] != 'PyVarObject_HEAD_INIT': + raise Exception('%s has no PyVarObject_HEAD_INIT' % name) + while tokens[pos][1] != ')': + pos += 1 + pos += 1 + # field definitions: various tokens, comma-separated + fields = [] + while True: + while tokens[pos][0] in ('ws', 'comment'): + pos += 1 + end = pos + while tokens[end][1] not in ',}': + if tokens[end][1] == '(': + nesting = 1 + while nesting: + end += 1 + if tokens[end][1] == '(': nesting+=1 + if tokens[end][1] == ')': nesting-=1 + end += 1 + assert end < real_end + # join field, excluding separator and trailing ws + end1 = end-1 + while tokens[end1][0] in ('ws', 'comment'): + end1 -= 1 + fields.append(''.join(t[1] for t in tokens[pos:end1+1])) + if tokens[end][1] == '}': + break + pos = end+1 + return name, fields + +# List of type slots as of Python 3.2, omitting ob_base +typeslots = [ + 'tp_name', + 'tp_basicsize', + 'tp_itemsize', + 'tp_dealloc', + 'tp_print', + 'tp_getattr', + 'tp_setattr', + 'tp_reserved', + 'tp_repr', + 'tp_as_number', + 'tp_as_sequence', + 'tp_as_mapping', + 'tp_hash', + 'tp_call', + 'tp_str', + 'tp_getattro', + 'tp_setattro', + 'tp_as_buffer', + 'tp_flags', + 'tp_doc', + 'tp_traverse', + 'tp_clear', + 'tp_richcompare', + 'tp_weaklistoffset', + 'tp_iter', + 'iternextfunc', + 'tp_methods', + 'tp_members', + 'tp_getset', + 'tp_base', + 'tp_dict', + 'tp_descr_get', + 'tp_descr_set', + 'tp_dictoffset', + 'tp_init', + 'tp_alloc', + 'tp_new', + 'tp_free', + 'tp_is_gc', + 'tp_bases', + 'tp_mro', + 'tp_cache', + 'tp_subclasses', + 'tp_weaklist', + 'tp_del', + 'tp_version_tag', +] + +# Generate a PyType_Spec definition +def make_slots(name, fields): + res = [] + res.append('static PyType_Slot %s_slots[] = {' % name) + # defaults for spec + spec = { 'tp_itemsize':'0' } + for i, val in enumerate(fields): + if val.endswith('0'): + continue + if typeslots[i] in ('tp_name', 'tp_doc', 'tp_basicsize', + 'tp_itemsize', 'tp_flags'): + spec[typeslots[i]] = val + continue + res.append(' {Py_%s, %s},' % (typeslots[i], val)) + res.append('};') + res.append('static PyType_Spec %s_spec = {' % name) + res.append(' %s,' % spec['tp_name']) + res.append(' %s,' % spec['tp_basicsize']) + res.append(' %s,' % spec['tp_itemsize']) + res.append(' %s,' % spec['tp_flags']) + res.append(' %s_slots,' % name) + res.append('};\n') + return '\n'.join(res) + + +if __name__ == '__main__': + + ############ Simplistic C scanner ################################## + tokenizer = re.compile( + r"(?P#.*\n)" + r"|(?P/\*.*?\*/)" + r"|(?P[a-zA-Z_][a-zA-Z0-9_]*)" + r"|(?P[ \t\n]+)" + r"|(?P.)", + re.MULTILINE) + + tokens = [] + source = sys.stdin.read() + pos = 0 + while pos != len(source): + m = tokenizer.match(source, pos) + tokens.append([m.lastgroup, m.group()]) + pos += len(tokens[-1][1]) + if tokens[-1][0] == 'preproc': + # continuation lines are considered + # only in preprocess statements + while tokens[-1][1].endswith('\\\n'): + nl = source.find('\n', pos) + if nl == -1: + line = source[pos:] + else: + line = source[pos:nl+1] + tokens[-1][1] += line + pos += len(line) + + # Main loop: replace all static PyTypeObjects until + # there are none left. + while 1: + c = classify() + m = re.search('(SW)?TWIW?=W?{.*?};', c) + if not m: + break + start = m.start() + end = m.end() + name, fields = get_fields(start, end) + tokens[start:end] = [('',make_slots(name, fields))] + + # Output result to stdout + for t, v in tokens: + sys.stdout.write(v) diff --git a/marketing/Tools/scripts/analyze_dxp.py b/marketing/Tools/scripts/analyze_dxp.py new file mode 100644 index 0000000000000000000000000000000000000000..bde931e75033aabbdda2fcac15b77e99ca39db64 --- /dev/null +++ b/marketing/Tools/scripts/analyze_dxp.py @@ -0,0 +1,129 @@ +""" +Some helper functions to analyze the output of sys.getdxp() (which is +only available if Python was built with -DDYNAMIC_EXECUTION_PROFILE). +These will tell you which opcodes have been executed most frequently +in the current process, and, if Python was also built with -DDXPAIRS, +will tell you which instruction _pairs_ were executed most frequently, +which may help in choosing new instructions. + +If Python was built without -DDYNAMIC_EXECUTION_PROFILE, importing +this module will raise a RuntimeError. + +If you're running a script you want to profile, a simple way to get +the common pairs is: + +$ PYTHONPATH=$PYTHONPATH:/Tools/scripts \ +./python -i -O the_script.py --args +... +> from analyze_dxp import * +> s = render_common_pairs() +> open('/tmp/some_file', 'w').write(s) +""" + +import copy +import opcode +import operator +import sys +import threading + +if not hasattr(sys, "getdxp"): + raise RuntimeError("Can't import analyze_dxp: Python built without" + " -DDYNAMIC_EXECUTION_PROFILE.") + + +_profile_lock = threading.RLock() +_cumulative_profile = sys.getdxp() + +# If Python was built with -DDXPAIRS, sys.getdxp() returns a list of +# lists of ints. Otherwise it returns just a list of ints. +def has_pairs(profile): + """Returns True if the Python that produced the argument profile + was built with -DDXPAIRS.""" + + return len(profile) > 0 and isinstance(profile[0], list) + + +def reset_profile(): + """Forgets any execution profile that has been gathered so far.""" + with _profile_lock: + sys.getdxp() # Resets the internal profile + global _cumulative_profile + _cumulative_profile = sys.getdxp() # 0s out our copy. + + +def merge_profile(): + """Reads sys.getdxp() and merges it into this module's cached copy. + + We need this because sys.getdxp() 0s itself every time it's called.""" + + with _profile_lock: + new_profile = sys.getdxp() + if has_pairs(new_profile): + for first_inst in range(len(_cumulative_profile)): + for second_inst in range(len(_cumulative_profile[first_inst])): + _cumulative_profile[first_inst][second_inst] += ( + new_profile[first_inst][second_inst]) + else: + for inst in range(len(_cumulative_profile)): + _cumulative_profile[inst] += new_profile[inst] + + +def snapshot_profile(): + """Returns the cumulative execution profile until this call.""" + with _profile_lock: + merge_profile() + return copy.deepcopy(_cumulative_profile) + + +def common_instructions(profile): + """Returns the most common opcodes in order of descending frequency. + + The result is a list of tuples of the form + (opcode, opname, # of occurrences) + + """ + if has_pairs(profile) and profile: + inst_list = profile[-1] + else: + inst_list = profile + result = [(op, opcode.opname[op], count) + for op, count in enumerate(inst_list) + if count > 0] + result.sort(key=operator.itemgetter(2), reverse=True) + return result + + +def common_pairs(profile): + """Returns the most common opcode pairs in order of descending frequency. + + The result is a list of tuples of the form + ((1st opcode, 2nd opcode), + (1st opname, 2nd opname), + # of occurrences of the pair) + + """ + if not has_pairs(profile): + return [] + result = [((op1, op2), (opcode.opname[op1], opcode.opname[op2]), count) + # Drop the row of single-op profiles with [:-1] + for op1, op1profile in enumerate(profile[:-1]) + for op2, count in enumerate(op1profile) + if count > 0] + result.sort(key=operator.itemgetter(2), reverse=True) + return result + + +def render_common_pairs(profile=None): + """Renders the most common opcode pairs to a string in order of + descending frequency. + + The result is a series of lines of the form: + # of occurrences: ('1st opname', '2nd opname') + + """ + if profile is None: + profile = snapshot_profile() + def seq(): + for _, ops, count in common_pairs(profile): + yield "%s: %s\n" % (count, ops) + return ''.join(seq()) diff --git a/marketing/Tools/scripts/byext.py b/marketing/Tools/scripts/byext.py new file mode 100644 index 0000000000000000000000000000000000000000..a4b2f7ff6d828b2697fb75f60dbdce8b1ef1dc63 --- /dev/null +++ b/marketing/Tools/scripts/byext.py @@ -0,0 +1,132 @@ +#! /usr/bin/env python3 + +"""Show file statistics by extension.""" + +import os +import sys + + +class Stats: + + def __init__(self): + self.stats = {} + + def statargs(self, args): + for arg in args: + if os.path.isdir(arg): + self.statdir(arg) + elif os.path.isfile(arg): + self.statfile(arg) + else: + sys.stderr.write("Can't find %s\n" % arg) + self.addstats("", "unknown", 1) + + def statdir(self, dir): + self.addstats("", "dirs", 1) + try: + names = os.listdir(dir) + except OSError as err: + sys.stderr.write("Can't list %s: %s\n" % (dir, err)) + self.addstats("", "unlistable", 1) + return + for name in sorted(names): + if name.startswith(".#"): + continue # Skip CVS temp files + if name.endswith("~"): + continue # Skip Emacs backup files + full = os.path.join(dir, name) + if os.path.islink(full): + self.addstats("", "links", 1) + elif os.path.isdir(full): + self.statdir(full) + else: + self.statfile(full) + + def statfile(self, filename): + head, ext = os.path.splitext(filename) + head, base = os.path.split(filename) + if ext == base: + ext = "" # E.g. .cvsignore is deemed not to have an extension + ext = os.path.normcase(ext) + if not ext: + ext = "" + self.addstats(ext, "files", 1) + try: + with open(filename, "rb") as f: + data = f.read() + except IOError as err: + sys.stderr.write("Can't open %s: %s\n" % (filename, err)) + self.addstats(ext, "unopenable", 1) + return + self.addstats(ext, "bytes", len(data)) + if b'\0' in data: + self.addstats(ext, "binary", 1) + return + if not data: + self.addstats(ext, "empty", 1) + # self.addstats(ext, "chars", len(data)) + lines = str(data, "latin-1").splitlines() + self.addstats(ext, "lines", len(lines)) + del lines + words = data.split() + self.addstats(ext, "words", len(words)) + + def addstats(self, ext, key, n): + d = self.stats.setdefault(ext, {}) + d[key] = d.get(key, 0) + n + + def report(self): + exts = sorted(self.stats) + # Get the column keys + columns = {} + for ext in exts: + columns.update(self.stats[ext]) + cols = sorted(columns) + colwidth = {} + colwidth["ext"] = max(map(len, exts)) + minwidth = 6 + self.stats["TOTAL"] = {} + for col in cols: + total = 0 + cw = max(minwidth, len(col)) + for ext in exts: + value = self.stats[ext].get(col) + if value is None: + w = 0 + else: + w = len("%d" % value) + total += value + cw = max(cw, w) + cw = max(cw, len(str(total))) + colwidth[col] = cw + self.stats["TOTAL"][col] = total + exts.append("TOTAL") + for ext in exts: + self.stats[ext]["ext"] = ext + cols.insert(0, "ext") + + def printheader(): + for col in cols: + print("%*s" % (colwidth[col], col), end=' ') + print() + + printheader() + for ext in exts: + for col in cols: + value = self.stats[ext].get(col, "") + print("%*s" % (colwidth[col], value), end=' ') + print() + printheader() # Another header at the bottom + + +def main(): + args = sys.argv[1:] + if not args: + args = [os.curdir] + s = Stats() + s.statargs(args) + s.report() + + +if __name__ == "__main__": + main() diff --git a/marketing/Tools/scripts/byteyears.py b/marketing/Tools/scripts/byteyears.py new file mode 100644 index 0000000000000000000000000000000000000000..f58c34608faaf4f56007941e83b18e98ed4c11bb --- /dev/null +++ b/marketing/Tools/scripts/byteyears.py @@ -0,0 +1,61 @@ +#! /usr/bin/env python3 + +# Print the product of age and size of each file, in suitable units. +# +# Usage: byteyears [ -a | -m | -c ] file ... +# +# Options -[amc] select atime, mtime (default) or ctime as age. + +import sys, os, time +from stat import * + +def main(): + + # Use lstat() to stat files if it exists, else stat() + try: + statfunc = os.lstat + except AttributeError: + statfunc = os.stat + + # Parse options + if sys.argv[1] == '-m': + itime = ST_MTIME + del sys.argv[1] + elif sys.argv[1] == '-c': + itime = ST_CTIME + del sys.argv[1] + elif sys.argv[1] == '-a': + itime = ST_CTIME + del sys.argv[1] + else: + itime = ST_MTIME + + secs_per_year = 365.0 * 24.0 * 3600.0 # Scale factor + now = time.time() # Current time, for age computations + status = 0 # Exit status, set to 1 on errors + + # Compute max file name length + maxlen = 1 + for filename in sys.argv[1:]: + maxlen = max(maxlen, len(filename)) + + # Process each argument in turn + for filename in sys.argv[1:]: + try: + st = statfunc(filename) + except OSError as msg: + sys.stderr.write("can't stat %r: %r\n" % (filename, msg)) + status = 1 + st = () + if st: + anytime = st[itime] + size = st[ST_SIZE] + age = now - anytime + byteyears = float(size) * float(age) / secs_per_year + print(filename.ljust(maxlen), end=' ') + print(repr(int(byteyears)).rjust(8)) + + sys.exit(status) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/checkpip.py b/marketing/Tools/scripts/checkpip.py new file mode 100644 index 0000000000000000000000000000000000000000..a4a9ddfa6f324a9c3079085f296917af9b4489ab --- /dev/null +++ b/marketing/Tools/scripts/checkpip.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +""" +Checks that the version of the projects bundled in ensurepip are the latest +versions available. +""" +import ensurepip +import json +import urllib.request +import sys + + +def main(): + outofdate = False + + for project, version in ensurepip._PROJECTS: + data = json.loads(urllib.request.urlopen( + "https://pypi.org/pypi/{}/json".format(project), + cadefault=True, + ).read().decode("utf8")) + upstream_version = data["info"]["version"] + + if version != upstream_version: + outofdate = True + print("The latest version of {} on PyPI is {}, but ensurepip " + "has {}".format(project, upstream_version, version)) + + if outofdate: + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/marketing/Tools/scripts/cleanfuture.py b/marketing/Tools/scripts/cleanfuture.py new file mode 100644 index 0000000000000000000000000000000000000000..94f69126321550d346ff3f58aa89c941b601294b --- /dev/null +++ b/marketing/Tools/scripts/cleanfuture.py @@ -0,0 +1,275 @@ +#! /usr/bin/env python3 + +"""cleanfuture [-d][-r][-v] path ... + +-d Dry run. Analyze, but don't make any changes to, files. +-r Recurse. Search for all .py files in subdirectories too. +-v Verbose. Print informative msgs. + +Search Python (.py) files for future statements, and remove the features +from such statements that are already mandatory in the version of Python +you're using. + +Pass one or more file and/or directory paths. When a directory path, all +.py files within the directory will be examined, and, if the -r option is +given, likewise recursively for subdirectories. + +Overwrites files in place, renaming the originals with a .bak extension. If +cleanfuture finds nothing to change, the file is left alone. If cleanfuture +does change a file, the changed file is a fixed-point (i.e., running +cleanfuture on the resulting .py file won't change it again, at least not +until you try it again with a later Python release). + +Limitations: You can do these things, but this tool won't help you then: + ++ A future statement cannot be mixed with any other statement on the same + physical line (separated by semicolon). + ++ A future statement cannot contain an "as" clause. + +Example: Assuming you're using Python 2.2, if a file containing + +from __future__ import nested_scopes, generators + +is analyzed by cleanfuture, the line is rewritten to + +from __future__ import generators + +because nested_scopes is no longer optional in 2.2 but generators is. +""" + +import __future__ +import tokenize +import os +import sys + +dryrun = 0 +recurse = 0 +verbose = 0 + +def errprint(*args): + strings = map(str, args) + msg = ' '.join(strings) + if msg[-1:] != '\n': + msg += '\n' + sys.stderr.write(msg) + +def main(): + import getopt + global verbose, recurse, dryrun + try: + opts, args = getopt.getopt(sys.argv[1:], "drv") + except getopt.error as msg: + errprint(msg) + return + for o, a in opts: + if o == '-d': + dryrun += 1 + elif o == '-r': + recurse += 1 + elif o == '-v': + verbose += 1 + if not args: + errprint("Usage:", __doc__) + return + for arg in args: + check(arg) + +def check(file): + if os.path.isdir(file) and not os.path.islink(file): + if verbose: + print("listing directory", file) + names = os.listdir(file) + for name in names: + fullname = os.path.join(file, name) + if ((recurse and os.path.isdir(fullname) and + not os.path.islink(fullname)) + or name.lower().endswith(".py")): + check(fullname) + return + + if verbose: + print("checking", file, "...", end=' ') + try: + f = open(file) + except IOError as msg: + errprint("%r: I/O Error: %s" % (file, str(msg))) + return + + with f: + ff = FutureFinder(f, file) + changed = ff.run() + if changed: + ff.gettherest() + if changed: + if verbose: + print("changed.") + if dryrun: + print("But this is a dry run, so leaving it alone.") + for s, e, line in changed: + print("%r lines %d-%d" % (file, s+1, e+1)) + for i in range(s, e+1): + print(ff.lines[i], end=' ') + if line is None: + print("-- deleted") + else: + print("-- change to:") + print(line, end=' ') + if not dryrun: + bak = file + ".bak" + if os.path.exists(bak): + os.remove(bak) + os.rename(file, bak) + if verbose: + print("renamed", file, "to", bak) + with open(file, "w") as g: + ff.write(g) + if verbose: + print("wrote new", file) + else: + if verbose: + print("unchanged.") + +class FutureFinder: + + def __init__(self, f, fname): + self.f = f + self.fname = fname + self.ateof = 0 + self.lines = [] # raw file lines + + # List of (start_index, end_index, new_line) triples. + self.changed = [] + + # Line-getter for tokenize. + def getline(self): + if self.ateof: + return "" + line = self.f.readline() + if line == "": + self.ateof = 1 + else: + self.lines.append(line) + return line + + def run(self): + STRING = tokenize.STRING + NL = tokenize.NL + NEWLINE = tokenize.NEWLINE + COMMENT = tokenize.COMMENT + NAME = tokenize.NAME + OP = tokenize.OP + + changed = self.changed + get = tokenize.generate_tokens(self.getline).__next__ + type, token, (srow, scol), (erow, ecol), line = get() + + # Chew up initial comments and blank lines (if any). + while type in (COMMENT, NL, NEWLINE): + type, token, (srow, scol), (erow, ecol), line = get() + + # Chew up docstring (if any -- and it may be implicitly catenated!). + while type is STRING: + type, token, (srow, scol), (erow, ecol), line = get() + + # Analyze the future stmts. + while 1: + # Chew up comments and blank lines (if any). + while type in (COMMENT, NL, NEWLINE): + type, token, (srow, scol), (erow, ecol), line = get() + + if not (type is NAME and token == "from"): + break + startline = srow - 1 # tokenize is one-based + type, token, (srow, scol), (erow, ecol), line = get() + + if not (type is NAME and token == "__future__"): + break + type, token, (srow, scol), (erow, ecol), line = get() + + if not (type is NAME and token == "import"): + break + type, token, (srow, scol), (erow, ecol), line = get() + + # Get the list of features. + features = [] + while type is NAME: + features.append(token) + type, token, (srow, scol), (erow, ecol), line = get() + + if not (type is OP and token == ','): + break + type, token, (srow, scol), (erow, ecol), line = get() + + # A trailing comment? + comment = None + if type is COMMENT: + comment = token + type, token, (srow, scol), (erow, ecol), line = get() + + if type is not NEWLINE: + errprint("Skipping file %r; can't parse line %d:\n%s" % + (self.fname, srow, line)) + return [] + + endline = srow - 1 + + # Check for obsolete features. + okfeatures = [] + for f in features: + object = getattr(__future__, f, None) + if object is None: + # A feature we don't know about yet -- leave it in. + # They'll get a compile-time error when they compile + # this program, but that's not our job to sort out. + okfeatures.append(f) + else: + released = object.getMandatoryRelease() + if released is None or released <= sys.version_info: + # Withdrawn or obsolete. + pass + else: + okfeatures.append(f) + + # Rewrite the line if at least one future-feature is obsolete. + if len(okfeatures) < len(features): + if len(okfeatures) == 0: + line = None + else: + line = "from __future__ import " + line += ', '.join(okfeatures) + if comment is not None: + line += ' ' + comment + line += '\n' + changed.append((startline, endline, line)) + + # Loop back for more future statements. + + return changed + + def gettherest(self): + if self.ateof: + self.therest = '' + else: + self.therest = self.f.read() + + def write(self, f): + changed = self.changed + assert changed + # Prevent calling this again. + self.changed = [] + # Apply changes in reverse order. + changed.reverse() + for s, e, line in changed: + if line is None: + # pure deletion + del self.lines[s:e+1] + else: + self.lines[s:e+1] = [line] + f.writelines(self.lines) + # Copy over the remainder of the file. + if self.therest: + f.write(self.therest) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/combinerefs.py b/marketing/Tools/scripts/combinerefs.py new file mode 100644 index 0000000000000000000000000000000000000000..49ccca73909fc8f715b84c3e08df3cecaf9977b4 --- /dev/null +++ b/marketing/Tools/scripts/combinerefs.py @@ -0,0 +1,129 @@ +#! /usr/bin/env python3 + +""" +combinerefs path + +A helper for analyzing PYTHONDUMPREFS output. + +When the PYTHONDUMPREFS envar is set in a debug build, at Python shutdown +time Py_FinalizeEx() prints the list of all live objects twice: first it +prints the repr() of each object while the interpreter is still fully intact. +After cleaning up everything it can, it prints all remaining live objects +again, but the second time just prints their addresses, refcounts, and type +names (because the interpreter has been torn down, calling repr methods at +this point can get into infinite loops or blow up). + +Save all this output into a file, then run this script passing the path to +that file. The script finds both output chunks, combines them, then prints +a line of output for each object still alive at the end: + + address refcnt typename repr + +address is the address of the object, in whatever format the platform C +produces for a %p format code. + +refcnt is of the form + + "[" ref "]" + +when the object's refcount is the same in both PYTHONDUMPREFS output blocks, +or + + "[" ref_before "->" ref_after "]" + +if the refcount changed. + +typename is object->ob_type->tp_name, extracted from the second PYTHONDUMPREFS +output block. + +repr is repr(object), extracted from the first PYTHONDUMPREFS output block. +CAUTION: If object is a container type, it may not actually contain all the +objects shown in the repr: the repr was captured from the first output block, +and some of the containees may have been released since then. For example, +it's common for the line showing the dict of interned strings to display +strings that no longer exist at the end of Py_FinalizeEx; this can be recognized +(albeit painfully) because such containees don't have a line of their own. + +The objects are listed in allocation order, with most-recently allocated +printed first, and the first object allocated printed last. + + +Simple examples: + + 00857060 [14] str '__len__' + +The str object '__len__' is alive at shutdown time, and both PYTHONDUMPREFS +output blocks said there were 14 references to it. This is probably due to +C modules that intern the string "__len__" and keep a reference to it in a +file static. + + 00857038 [46->5] tuple () + +46-5 = 41 references to the empty tuple were removed by the cleanup actions +between the times PYTHONDUMPREFS produced output. + + 00858028 [1025->1456] str '' + +The string '', which is used in dictobject.c to overwrite a real +key that gets deleted, grew several hundred references during cleanup. It +suggests that stuff did get removed from dicts by cleanup, but that the dicts +themselves are staying alive for some reason. """ + +import re +import sys + +# Generate lines from fileiter. If whilematch is true, continue reading +# while the regexp object pat matches line. If whilematch is false, lines +# are read so long as pat doesn't match them. In any case, the first line +# that doesn't match pat (when whilematch is true), or that does match pat +# (when whilematch is false), is lost, and fileiter will resume at the line +# following it. +def read(fileiter, pat, whilematch): + for line in fileiter: + if bool(pat.match(line)) == whilematch: + yield line + else: + break + +def combinefile(f): + fi = iter(f) + + for line in read(fi, re.compile(r'^Remaining objects:$'), False): + pass + + crack = re.compile(r'([a-zA-Z\d]+) \[(\d+)\] (.*)') + addr2rc = {} + addr2guts = {} + before = 0 + for line in read(fi, re.compile(r'^Remaining object addresses:$'), False): + m = crack.match(line) + if m: + addr, addr2rc[addr], addr2guts[addr] = m.groups() + before += 1 + else: + print('??? skipped:', line) + + after = 0 + for line in read(fi, crack, True): + after += 1 + m = crack.match(line) + assert m + addr, rc, guts = m.groups() # guts is type name here + if addr not in addr2rc: + print('??? new object created while tearing down:', line.rstrip()) + continue + print(addr, end=' ') + if rc == addr2rc[addr]: + print('[%s]' % rc, end=' ') + else: + print('[%s->%s]' % (addr2rc[addr], rc), end=' ') + print(guts, addr2guts[addr]) + + print("%d objects before, %d after" % (before, after)) + +def combine(fname): + with open(fname) as f: + combinefile(f) + +if __name__ == '__main__': + combine(sys.argv[1]) diff --git a/marketing/Tools/scripts/copytime.py b/marketing/Tools/scripts/copytime.py new file mode 100644 index 0000000000000000000000000000000000000000..715683f12557ca6c55eedaf9c103fea6e5d2ee83 --- /dev/null +++ b/marketing/Tools/scripts/copytime.py @@ -0,0 +1,26 @@ +#! /usr/bin/env python3 + +# Copy one file's atime and mtime to another + +import sys +import os +from stat import ST_ATIME, ST_MTIME # Really constants 7 and 8 + +def main(): + if len(sys.argv) != 3: + sys.stderr.write('usage: copytime source destination\n') + sys.exit(2) + file1, file2 = sys.argv[1], sys.argv[2] + try: + stat1 = os.stat(file1) + except OSError: + sys.stderr.write(file1 + ': cannot stat\n') + sys.exit(1) + try: + os.utime(file2, (stat1[ST_ATIME], stat1[ST_MTIME])) + except OSError: + sys.stderr.write(file2 + ': cannot change time\n') + sys.exit(2) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/crlf.py b/marketing/Tools/scripts/crlf.py new file mode 100644 index 0000000000000000000000000000000000000000..f231d292cebecdbda51f7e01b8c67beb15f0f4fa --- /dev/null +++ b/marketing/Tools/scripts/crlf.py @@ -0,0 +1,23 @@ +#! /usr/bin/env python3 +"Replace CRLF with LF in argument files. Print names of changed files." + +import sys, os + +def main(): + for filename in sys.argv[1:]: + if os.path.isdir(filename): + print(filename, "Directory!") + continue + with open(filename, "rb") as f: + data = f.read() + if b'\0' in data: + print(filename, "Binary!") + continue + newdata = data.replace(b"\r\n", b"\n") + if newdata != data: + print(filename) + with open(filename, "wb") as f: + f.write(newdata) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/db2pickle.py b/marketing/Tools/scripts/db2pickle.py new file mode 100644 index 0000000000000000000000000000000000000000..a5532a8f3a412e3e8058c160ae28c9d3e410d7cf --- /dev/null +++ b/marketing/Tools/scripts/db2pickle.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python3 + +""" +Synopsis: %(prog)s [-h|-g|-b|-r|-a] dbfile [ picklefile ] + +Convert the database file given on the command line to a pickle +representation. The optional flags indicate the type of the database: + + -a - open using dbm (any supported format) + -b - open as bsddb btree file + -d - open as dbm file + -g - open as gdbm file + -h - open as bsddb hash file + -r - open as bsddb recno file + +The default is hash. If a pickle file is named it is opened for write +access (deleting any existing data). If no pickle file is named, the pickle +output is written to standard output. + +""" + +import getopt +try: + import bsddb +except ImportError: + bsddb = None +try: + import dbm.ndbm as dbm +except ImportError: + dbm = None +try: + import dbm.gnu as gdbm +except ImportError: + gdbm = None +try: + import dbm.ndbm as anydbm +except ImportError: + anydbm = None +import sys +try: + import pickle as pickle +except ImportError: + import pickle + +prog = sys.argv[0] + +def usage(): + sys.stderr.write(__doc__ % globals()) + +def main(args): + try: + opts, args = getopt.getopt(args, "hbrdag", + ["hash", "btree", "recno", "dbm", + "gdbm", "anydbm"]) + except getopt.error: + usage() + return 1 + + if len(args) == 0 or len(args) > 2: + usage() + return 1 + elif len(args) == 1: + dbfile = args[0] + pfile = sys.stdout + else: + dbfile = args[0] + try: + pfile = open(args[1], 'wb') + except IOError: + sys.stderr.write("Unable to open %s\n" % args[1]) + return 1 + + dbopen = None + for opt, arg in opts: + if opt in ("-h", "--hash"): + try: + dbopen = bsddb.hashopen + except AttributeError: + sys.stderr.write("bsddb module unavailable.\n") + return 1 + elif opt in ("-b", "--btree"): + try: + dbopen = bsddb.btopen + except AttributeError: + sys.stderr.write("bsddb module unavailable.\n") + return 1 + elif opt in ("-r", "--recno"): + try: + dbopen = bsddb.rnopen + except AttributeError: + sys.stderr.write("bsddb module unavailable.\n") + return 1 + elif opt in ("-a", "--anydbm"): + try: + dbopen = anydbm.open + except AttributeError: + sys.stderr.write("dbm module unavailable.\n") + return 1 + elif opt in ("-g", "--gdbm"): + try: + dbopen = gdbm.open + except AttributeError: + sys.stderr.write("dbm.gnu module unavailable.\n") + return 1 + elif opt in ("-d", "--dbm"): + try: + dbopen = dbm.open + except AttributeError: + sys.stderr.write("dbm.ndbm module unavailable.\n") + return 1 + if dbopen is None: + if bsddb is None: + sys.stderr.write("bsddb module unavailable - ") + sys.stderr.write("must specify dbtype.\n") + return 1 + else: + dbopen = bsddb.hashopen + + try: + db = dbopen(dbfile, 'r') + except bsddb.error: + sys.stderr.write("Unable to open %s. " % dbfile) + sys.stderr.write("Check for format or version mismatch.\n") + return 1 + + for k in db.keys(): + pickle.dump((k, db[k]), pfile, 1==1) + + db.close() + pfile.close() + + return 0 + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/marketing/Tools/scripts/diff.py b/marketing/Tools/scripts/diff.py new file mode 100644 index 0000000000000000000000000000000000000000..96199b85116d7d06acb756c48bdee045bd28c8d0 --- /dev/null +++ b/marketing/Tools/scripts/diff.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +""" Command line interface to difflib.py providing diffs in four formats: + +* ndiff: lists every line and highlights interline changes. +* context: highlights clusters of changes in a before/after format. +* unified: highlights clusters of changes in an inline format. +* html: generates side by side comparison with change highlights. + +""" + +import sys, os, difflib, argparse +from datetime import datetime, timezone + +def file_mtime(path): + t = datetime.fromtimestamp(os.stat(path).st_mtime, + timezone.utc) + return t.astimezone().isoformat() + +def main(): + + parser = argparse.ArgumentParser() + parser.add_argument('-c', action='store_true', default=False, + help='Produce a context format diff (default)') + parser.add_argument('-u', action='store_true', default=False, + help='Produce a unified format diff') + parser.add_argument('-m', action='store_true', default=False, + help='Produce HTML side by side diff ' + '(can use -c and -l in conjunction)') + parser.add_argument('-n', action='store_true', default=False, + help='Produce a ndiff format diff') + parser.add_argument('-l', '--lines', type=int, default=3, + help='Set number of context lines (default 3)') + parser.add_argument('fromfile') + parser.add_argument('tofile') + options = parser.parse_args() + + n = options.lines + fromfile = options.fromfile + tofile = options.tofile + + fromdate = file_mtime(fromfile) + todate = file_mtime(tofile) + with open(fromfile) as ff: + fromlines = ff.readlines() + with open(tofile) as tf: + tolines = tf.readlines() + + if options.u: + diff = difflib.unified_diff(fromlines, tolines, fromfile, tofile, fromdate, todate, n=n) + elif options.n: + diff = difflib.ndiff(fromlines, tolines) + elif options.m: + diff = difflib.HtmlDiff().make_file(fromlines,tolines,fromfile,tofile,context=options.c,numlines=n) + else: + diff = difflib.context_diff(fromlines, tolines, fromfile, tofile, fromdate, todate, n=n) + + sys.stdout.writelines(diff) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/dutree.py b/marketing/Tools/scripts/dutree.py new file mode 100644 index 0000000000000000000000000000000000000000..d25cf72b707ecf8f1fe2121a8da50f11d3617dc3 --- /dev/null +++ b/marketing/Tools/scripts/dutree.py @@ -0,0 +1,60 @@ +#! /usr/bin/env python3 +# Format du output in a tree shape + +import os, sys, errno + +def main(): + total, d = None, {} + with os.popen('du ' + ' '.join(sys.argv[1:])) as p: + for line in p: + i = 0 + while line[i] in '0123456789': i = i+1 + size = eval(line[:i]) + while line[i] in ' \t': i = i+1 + filename = line[i:-1] + comps = filename.split('/') + if comps[0] == '': comps[0] = '/' + if comps[len(comps)-1] == '': del comps[len(comps)-1] + total, d = store(size, comps, total, d) + try: + display(total, d) + except IOError as e: + if e.errno != errno.EPIPE: + raise + +def store(size, comps, total, d): + if comps == []: + return size, d + if comps[0] not in d: + d[comps[0]] = None, {} + t1, d1 = d[comps[0]] + d[comps[0]] = store(size, comps[1:], t1, d1) + return total, d + +def display(total, d): + show(total, d, '') + +def show(total, d, prefix): + if not d: return + list = [] + sum = 0 + for key in d.keys(): + tsub, dsub = d[key] + list.append((tsub, key)) + if tsub is not None: sum = sum + tsub +## if sum < total: +## list.append((total - sum, os.curdir)) + list.sort() + list.reverse() + width = len(repr(list[0][0])) + for tsub, key in list: + if tsub is None: + psub = prefix + else: + print(prefix + repr(tsub).rjust(width) + ' ' + key) + psub = prefix + ' '*(width-1) + '|' + ' '*(len(key)+1) + if key in d: + show(tsub, d[key][1], psub) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/eptags.py b/marketing/Tools/scripts/eptags.py new file mode 100644 index 0000000000000000000000000000000000000000..7f8059ba71adf33d733c57405095c43263e7713f --- /dev/null +++ b/marketing/Tools/scripts/eptags.py @@ -0,0 +1,57 @@ +#! /usr/bin/env python3 +"""Create a TAGS file for Python programs, usable with GNU Emacs. + +usage: eptags pyfiles... + +The output TAGS file is usable with Emacs version 18, 19, 20. +Tagged are: + - functions (even inside other defs or classes) + - classes + +eptags warns about files it cannot open. +eptags will not give warnings about duplicate tags. + +BUGS: + Because of tag duplication (methods with the same name in different + classes), TAGS files are not very useful for most object-oriented + python projects. +""" +import sys,re + +expr = r'^[ \t]*(def|class)[ \t]+([a-zA-Z_][a-zA-Z0-9_]*)[ \t]*[:\(]' +matcher = re.compile(expr) + +def treat_file(filename, outfp): + """Append tags found in file named 'filename' to the open file 'outfp'""" + try: + fp = open(filename, 'r') + except OSError: + sys.stderr.write('Cannot open %s\n'%filename) + return + with fp: + charno = 0 + lineno = 0 + tags = [] + size = 0 + while 1: + line = fp.readline() + if not line: + break + lineno = lineno + 1 + m = matcher.search(line) + if m: + tag = m.group(0) + '\177%d,%d\n' % (lineno, charno) + tags.append(tag) + size = size + len(tag) + charno = charno + len(line) + outfp.write('\f\n%s,%d\n' % (filename,size)) + for tag in tags: + outfp.write(tag) + +def main(): + with open('TAGS', 'w') as outfp: + for filename in sys.argv[1:]: + treat_file(filename, outfp) + +if __name__=="__main__": + main() diff --git a/marketing/Tools/scripts/find-uname.py b/marketing/Tools/scripts/find-uname.py new file mode 100644 index 0000000000000000000000000000000000000000..b6ec1b6d79060cfa6705dab7dfe4c258da21d304 --- /dev/null +++ b/marketing/Tools/scripts/find-uname.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python3 + +""" +For each argument on the command line, look for it in the set of all Unicode +names. Arguments are treated as case-insensitive regular expressions, e.g.: + + % find-uname 'small letter a$' 'horizontal line' + *** small letter a$ matches *** + LATIN SMALL LETTER A (97) + COMBINING LATIN SMALL LETTER A (867) + CYRILLIC SMALL LETTER A (1072) + PARENTHESIZED LATIN SMALL LETTER A (9372) + CIRCLED LATIN SMALL LETTER A (9424) + FULLWIDTH LATIN SMALL LETTER A (65345) + *** horizontal line matches *** + HORIZONTAL LINE EXTENSION (9135) +""" + +import unicodedata +import sys +import re + +def main(args): + unicode_names = [] + for ix in range(sys.maxunicode+1): + try: + unicode_names.append((ix, unicodedata.name(chr(ix)))) + except ValueError: # no name for the character + pass + for arg in args: + pat = re.compile(arg, re.I) + matches = [(y,x) for (x,y) in unicode_names + if pat.search(y) is not None] + if matches: + print("***", arg, "matches", "***") + for match in matches: + print("%s (%d)" % match) + +if __name__ == "__main__": + main(sys.argv[1:]) diff --git a/marketing/Tools/scripts/find_recursionlimit.py b/marketing/Tools/scripts/find_recursionlimit.py new file mode 100644 index 0000000000000000000000000000000000000000..b2842a62efdbd682ce5f6a4f913d19d9823c32aa --- /dev/null +++ b/marketing/Tools/scripts/find_recursionlimit.py @@ -0,0 +1,128 @@ +#! /usr/bin/env python3 +"""Find the maximum recursion limit that prevents interpreter termination. + +This script finds the maximum safe recursion limit on a particular +platform. If you need to change the recursion limit on your system, +this script will tell you a safe upper bound. To use the new limit, +call sys.setrecursionlimit(). + +This module implements several ways to create infinite recursion in +Python. Different implementations end up pushing different numbers of +C stack frames, depending on how many calls through Python's abstract +C API occur. + +After each round of tests, it prints a message: +"Limit of NNNN is fine". + +The highest printed value of "NNNN" is therefore the highest potentially +safe limit for your system (which depends on the OS, architecture, but also +the compilation flags). Please note that it is practically impossible to +test all possible recursion paths in the interpreter, so the results of +this test should not be trusted blindly -- although they give a good hint +of which values are reasonable. + +NOTE: When the C stack space allocated by your system is exceeded due +to excessive recursion, exact behaviour depends on the platform, although +the interpreter will always fail in a likely brutal way: either a +segmentation fault, a MemoryError, or just a silent abort. + +NB: A program that does not use __methods__ can set a higher limit. +""" + +import sys +import itertools + +class RecursiveBlowup1: + def __init__(self): + self.__init__() + +def test_init(): + return RecursiveBlowup1() + +class RecursiveBlowup2: + def __repr__(self): + return repr(self) + +def test_repr(): + return repr(RecursiveBlowup2()) + +class RecursiveBlowup4: + def __add__(self, x): + return x + self + +def test_add(): + return RecursiveBlowup4() + RecursiveBlowup4() + +class RecursiveBlowup5: + def __getattr__(self, attr): + return getattr(self, attr) + +def test_getattr(): + return RecursiveBlowup5().attr + +class RecursiveBlowup6: + def __getitem__(self, item): + return self[item - 2] + self[item - 1] + +def test_getitem(): + return RecursiveBlowup6()[5] + +def test_recurse(): + return test_recurse() + +def test_cpickle(_cache={}): + import io + try: + import _pickle + except ImportError: + print("cannot import _pickle, skipped!") + return + k, l = None, None + for n in itertools.count(): + try: + l = _cache[n] + continue # Already tried and it works, let's save some time + except KeyError: + for i in range(100): + l = [k, l] + k = {i: l} + _pickle.Pickler(io.BytesIO(), protocol=-1).dump(l) + _cache[n] = l + +def test_compiler_recursion(): + # The compiler uses a scaling factor to support additional levels + # of recursion. This is a sanity check of that scaling to ensure + # it still raises RecursionError even at higher recursion limits + compile("()" * (10 * sys.getrecursionlimit()), "", "single") + +def check_limit(n, test_func_name): + sys.setrecursionlimit(n) + if test_func_name.startswith("test_"): + print(test_func_name[5:]) + else: + print(test_func_name) + test_func = globals()[test_func_name] + try: + test_func() + # AttributeError can be raised because of the way e.g. PyDict_GetItem() + # silences all exceptions and returns NULL, which is usually interpreted + # as "missing attribute". + except (RecursionError, AttributeError): + pass + else: + print("Yikes!") + +if __name__ == '__main__': + + limit = 1000 + while 1: + check_limit(limit, "test_recurse") + check_limit(limit, "test_add") + check_limit(limit, "test_repr") + check_limit(limit, "test_init") + check_limit(limit, "test_getattr") + check_limit(limit, "test_getitem") + check_limit(limit, "test_cpickle") + check_limit(limit, "test_compiler_recursion") + print("Limit of %d is fine" % limit) + limit = limit + 100 diff --git a/marketing/Tools/scripts/finddiv.py b/marketing/Tools/scripts/finddiv.py new file mode 100644 index 0000000000000000000000000000000000000000..d21253cf1c8a14c9b42fd9976f7cfe1b24723da9 --- /dev/null +++ b/marketing/Tools/scripts/finddiv.py @@ -0,0 +1,89 @@ +#! /usr/bin/env python3 + +"""finddiv - a grep-like tool that looks for division operators. + +Usage: finddiv [-l] file_or_directory ... + +For directory arguments, all files in the directory whose name ends in +.py are processed, and subdirectories are processed recursively. + +This actually tokenizes the files to avoid false hits in comments or +strings literals. + +By default, this prints all lines containing a / or /= operator, in +grep -n style. With the -l option specified, it prints the filename +of files that contain at least one / or /= operator. +""" + +import os +import sys +import getopt +import tokenize + +def main(): + try: + opts, args = getopt.getopt(sys.argv[1:], "lh") + except getopt.error as msg: + usage(msg) + return 2 + if not args: + usage("at least one file argument is required") + return 2 + listnames = 0 + for o, a in opts: + if o == "-h": + print(__doc__) + return + if o == "-l": + listnames = 1 + exit = None + for filename in args: + x = process(filename, listnames) + exit = exit or x + return exit + +def usage(msg): + sys.stderr.write("%s: %s\n" % (sys.argv[0], msg)) + sys.stderr.write("Usage: %s [-l] file ...\n" % sys.argv[0]) + sys.stderr.write("Try `%s -h' for more information.\n" % sys.argv[0]) + +def process(filename, listnames): + if os.path.isdir(filename): + return processdir(filename, listnames) + try: + fp = open(filename) + except IOError as msg: + sys.stderr.write("Can't open: %s\n" % msg) + return 1 + with fp: + g = tokenize.generate_tokens(fp.readline) + lastrow = None + for type, token, (row, col), end, line in g: + if token in ("/", "/="): + if listnames: + print(filename) + break + if row != lastrow: + lastrow = row + print("%s:%d:%s" % (filename, row, line), end=' ') + +def processdir(dir, listnames): + try: + names = os.listdir(dir) + except OSError as msg: + sys.stderr.write("Can't list directory: %s\n" % dir) + return 1 + files = [] + for name in names: + fn = os.path.join(dir, name) + if os.path.normcase(fn).endswith(".py") or os.path.isdir(fn): + files.append(fn) + files.sort(key=os.path.normcase) + exit = None + for fn in files: + x = process(fn, listnames) + exit = exit or x + return exit + +if __name__ == "__main__": + sys.exit(main()) diff --git a/marketing/Tools/scripts/findlinksto.py b/marketing/Tools/scripts/findlinksto.py new file mode 100644 index 0000000000000000000000000000000000000000..b924f27b095eb0704678121bca87017aca0fc754 --- /dev/null +++ b/marketing/Tools/scripts/findlinksto.py @@ -0,0 +1,43 @@ +#! /usr/bin/env python3 + +# findlinksto +# +# find symbolic links to a path matching a regular expression + +import os +import sys +import re +import getopt + +def main(): + try: + opts, args = getopt.getopt(sys.argv[1:], '') + if len(args) < 2: + raise getopt.GetoptError('not enough arguments', None) + except getopt.GetoptError as msg: + sys.stdout = sys.stderr + print(msg) + print('usage: findlinksto pattern directory ...') + sys.exit(2) + pat, dirs = args[0], args[1:] + prog = re.compile(pat) + for dirname in dirs: + os.walk(dirname, visit, prog) + +def visit(prog, dirname, names): + if os.path.islink(dirname): + names[:] = [] + return + if os.path.ismount(dirname): + print('descend into', dirname) + for name in names: + name = os.path.join(dirname, name) + try: + linkto = os.readlink(name) + if prog.search(linkto) is not None: + print(name, '->', linkto) + except OSError: + pass + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/findnocoding.py b/marketing/Tools/scripts/findnocoding.py new file mode 100644 index 0000000000000000000000000000000000000000..6c16b1ce151852da1a54e7aedb515c0e5c898290 --- /dev/null +++ b/marketing/Tools/scripts/findnocoding.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 + +"""List all those Python files that require a coding directive + +Usage: findnocoding.py dir1 [dir2...] +""" + +__author__ = "Oleg Broytmann, Georg Brandl" + +import sys, os, re, getopt + +# our pysource module finds Python source files +try: + import pysource +except ImportError: + # emulate the module with a simple os.walk + class pysource: + has_python_ext = looks_like_python = can_be_compiled = None + def walk_python_files(self, paths, *args, **kwargs): + for path in paths: + if os.path.isfile(path): + yield path.endswith(".py") + elif os.path.isdir(path): + for root, dirs, files in os.walk(path): + for filename in files: + if filename.endswith(".py"): + yield os.path.join(root, filename) + pysource = pysource() + + + print("The pysource module is not available; " + "no sophisticated Python source file search will be done.", file=sys.stderr) + + +decl_re = re.compile(rb'^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)') +blank_re = re.compile(rb'^[ \t\f]*(?:[#\r\n]|$)') + +def get_declaration(line): + match = decl_re.match(line) + if match: + return match.group(1) + return b'' + +def has_correct_encoding(text, codec): + try: + str(text, codec) + except UnicodeDecodeError: + return False + else: + return True + +def needs_declaration(fullpath): + try: + infile = open(fullpath, 'rb') + except IOError: # Oops, the file was removed - ignore it + return None + + with infile: + line1 = infile.readline() + line2 = infile.readline() + + if (get_declaration(line1) or + blank_re.match(line1) and get_declaration(line2)): + # the file does have an encoding declaration, so trust it + return False + + # check the whole file for non utf-8 characters + rest = infile.read() + + if has_correct_encoding(line1+line2+rest, "utf-8"): + return False + + return True + + +usage = """Usage: %s [-cd] paths... + -c: recognize Python source files trying to compile them + -d: debug output""" % sys.argv[0] + +if __name__ == '__main__': + + try: + opts, args = getopt.getopt(sys.argv[1:], 'cd') + except getopt.error as msg: + print(msg, file=sys.stderr) + print(usage, file=sys.stderr) + sys.exit(1) + + is_python = pysource.looks_like_python + debug = False + + for o, a in opts: + if o == '-c': + is_python = pysource.can_be_compiled + elif o == '-d': + debug = True + + if not args: + print(usage, file=sys.stderr) + sys.exit(1) + + for fullpath in pysource.walk_python_files(args, is_python): + if debug: + print("Testing for coding: %s" % fullpath) + result = needs_declaration(fullpath) + if result: + print(fullpath) diff --git a/marketing/Tools/scripts/fixcid.py b/marketing/Tools/scripts/fixcid.py new file mode 100644 index 0000000000000000000000000000000000000000..8f35eaeeb4f61f36f1de35a6259c0920464dc3dc --- /dev/null +++ b/marketing/Tools/scripts/fixcid.py @@ -0,0 +1,316 @@ +#! /usr/bin/env python3 + +# Perform massive identifier substitution on C source files. +# This actually tokenizes the files (to some extent) so it can +# avoid making substitutions inside strings or comments. +# Inside strings, substitutions are never made; inside comments, +# it is a user option (off by default). +# +# The substitutions are read from one or more files whose lines, +# when not empty, after stripping comments starting with #, +# must contain exactly two words separated by whitespace: the +# old identifier and its replacement. +# +# The option -r reverses the sense of the substitutions (this may be +# useful to undo a particular substitution). +# +# If the old identifier is prefixed with a '*' (with no intervening +# whitespace), then it will not be substituted inside comments. +# +# Command line arguments are files or directories to be processed. +# Directories are searched recursively for files whose name looks +# like a C file (ends in .h or .c). The special filename '-' means +# operate in filter mode: read stdin, write stdout. +# +# Symbolic links are always ignored (except as explicit directory +# arguments). +# +# The original files are kept as back-up with a "~" suffix. +# +# Changes made are reported to stdout in a diff-like format. +# +# NB: by changing only the function fixline() you can turn this +# into a program for different changes to C source files; by +# changing the function wanted() you can make a different selection of +# files. + +import sys +import re +import os +from stat import * +import getopt + +err = sys.stderr.write +dbg = err +rep = sys.stdout.write + +def usage(): + progname = sys.argv[0] + err('Usage: ' + progname + + ' [-c] [-r] [-s file] ... file-or-directory ...\n') + err('\n') + err('-c : substitute inside comments\n') + err('-r : reverse direction for following -s options\n') + err('-s substfile : add a file of substitutions\n') + err('\n') + err('Each non-empty non-comment line in a substitution file must\n') + err('contain exactly two words: an identifier and its replacement.\n') + err('Comments start with a # character and end at end of line.\n') + err('If an identifier is preceded with a *, it is not substituted\n') + err('inside a comment even when -c is specified.\n') + +def main(): + try: + opts, args = getopt.getopt(sys.argv[1:], 'crs:') + except getopt.error as msg: + err('Options error: ' + str(msg) + '\n') + usage() + sys.exit(2) + bad = 0 + if not args: # No arguments + usage() + sys.exit(2) + for opt, arg in opts: + if opt == '-c': + setdocomments() + if opt == '-r': + setreverse() + if opt == '-s': + addsubst(arg) + for arg in args: + if os.path.isdir(arg): + if recursedown(arg): bad = 1 + elif os.path.islink(arg): + err(arg + ': will not process symbolic links\n') + bad = 1 + else: + if fix(arg): bad = 1 + sys.exit(bad) + +# Change this regular expression to select a different set of files +Wanted = r'^[a-zA-Z0-9_]+\.[ch]$' +def wanted(name): + return re.match(Wanted, name) + +def recursedown(dirname): + dbg('recursedown(%r)\n' % (dirname,)) + bad = 0 + try: + names = os.listdir(dirname) + except OSError as msg: + err(dirname + ': cannot list directory: ' + str(msg) + '\n') + return 1 + names.sort() + subdirs = [] + for name in names: + if name in (os.curdir, os.pardir): continue + fullname = os.path.join(dirname, name) + if os.path.islink(fullname): pass + elif os.path.isdir(fullname): + subdirs.append(fullname) + elif wanted(name): + if fix(fullname): bad = 1 + for fullname in subdirs: + if recursedown(fullname): bad = 1 + return bad + +def fix(filename): +## dbg('fix(%r)\n' % (filename,)) + if filename == '-': + # Filter mode + f = sys.stdin + g = sys.stdout + else: + # File replacement mode + try: + f = open(filename, 'r') + except IOError as msg: + err(filename + ': cannot open: ' + str(msg) + '\n') + return 1 + head, tail = os.path.split(filename) + tempname = os.path.join(head, '@' + tail) + g = None + # If we find a match, we rewind the file and start over but + # now copy everything to a temp file. + lineno = 0 + initfixline() + while 1: + line = f.readline() + if not line: break + lineno = lineno + 1 + while line[-2:] == '\\\n': + nextline = f.readline() + if not nextline: break + line = line + nextline + lineno = lineno + 1 + newline = fixline(line) + if newline != line: + if g is None: + try: + g = open(tempname, 'w') + except IOError as msg: + f.close() + err(tempname+': cannot create: '+ + str(msg)+'\n') + return 1 + f.seek(0) + lineno = 0 + initfixline() + rep(filename + ':\n') + continue # restart from the beginning + rep(repr(lineno) + '\n') + rep('< ' + line) + rep('> ' + newline) + if g is not None: + g.write(newline) + + # End of file + if filename == '-': return 0 # Done in filter mode + f.close() + if not g: return 0 # No changes + g.close() + + # Finishing touch -- move files + + # First copy the file's mode to the temp file + try: + statbuf = os.stat(filename) + os.chmod(tempname, statbuf[ST_MODE] & 0o7777) + except OSError as msg: + err(tempname + ': warning: chmod failed (' + str(msg) + ')\n') + # Then make a backup of the original file as filename~ + try: + os.rename(filename, filename + '~') + except OSError as msg: + err(filename + ': warning: backup failed (' + str(msg) + ')\n') + # Now move the temp file to the original file + try: + os.rename(tempname, filename) + except OSError as msg: + err(filename + ': rename failed (' + str(msg) + ')\n') + return 1 + # Return success + return 0 + +# Tokenizing ANSI C (partly) + +Identifier = '(struct )?[a-zA-Z_][a-zA-Z0-9_]+' +String = r'"([^\n\\"]|\\.)*"' +Char = r"'([^\n\\']|\\.)*'" +CommentStart = r'/\*' +CommentEnd = r'\*/' + +Hexnumber = '0[xX][0-9a-fA-F]*[uUlL]*' +Octnumber = '0[0-7]*[uUlL]*' +Decnumber = '[1-9][0-9]*[uUlL]*' +Intnumber = Hexnumber + '|' + Octnumber + '|' + Decnumber +Exponent = '[eE][-+]?[0-9]+' +Pointfloat = r'([0-9]+\.[0-9]*|\.[0-9]+)(' + Exponent + r')?' +Expfloat = '[0-9]+' + Exponent +Floatnumber = Pointfloat + '|' + Expfloat +Number = Floatnumber + '|' + Intnumber + +# Anything else is an operator -- don't list this explicitly because of '/*' + +OutsideComment = (Identifier, Number, String, Char, CommentStart) +OutsideCommentPattern = '(' + '|'.join(OutsideComment) + ')' +OutsideCommentProgram = re.compile(OutsideCommentPattern) + +InsideComment = (Identifier, Number, CommentEnd) +InsideCommentPattern = '(' + '|'.join(InsideComment) + ')' +InsideCommentProgram = re.compile(InsideCommentPattern) + +def initfixline(): + global Program + Program = OutsideCommentProgram + +def fixline(line): + global Program +## print('-->', repr(line)) + i = 0 + while i < len(line): + match = Program.search(line, i) + if match is None: break + i = match.start() + found = match.group(0) +## if Program is InsideCommentProgram: print(end='... ') +## else: print(end=' ') +## print(found) + if len(found) == 2: + if found == '/*': + Program = InsideCommentProgram + elif found == '*/': + Program = OutsideCommentProgram + n = len(found) + if found in Dict: + subst = Dict[found] + if Program is InsideCommentProgram: + if not Docomments: + print('Found in comment:', found) + i = i + n + continue + if found in NotInComment: +## print(end='Ignored in comment: ') +## print(found, '-->', subst) +## print('Line:', line, end='') + subst = found +## else: +## print(end='Substituting in comment: ') +## print(found, '-->', subst) +## print('Line:', line, end='') + line = line[:i] + subst + line[i+n:] + n = len(subst) + i = i + n + return line + +Docomments = 0 +def setdocomments(): + global Docomments + Docomments = 1 + +Reverse = 0 +def setreverse(): + global Reverse + Reverse = (not Reverse) + +Dict = {} +NotInComment = {} +def addsubst(substfile): + try: + fp = open(substfile, 'r') + except IOError as msg: + err(substfile + ': cannot read substfile: ' + str(msg) + '\n') + sys.exit(1) + with fp: + lineno = 0 + while 1: + line = fp.readline() + if not line: break + lineno = lineno + 1 + try: + i = line.index('#') + except ValueError: + i = -1 # Happens to delete trailing \n + words = line[:i].split() + if not words: continue + if len(words) == 3 and words[0] == 'struct': + words[:2] = [words[0] + ' ' + words[1]] + elif len(words) != 2: + err(substfile + '%s:%r: warning: bad line: %r' % (substfile, lineno, line)) + continue + if Reverse: + [value, key] = words + else: + [key, value] = words + if value[0] == '*': + value = value[1:] + if key[0] == '*': + key = key[1:] + NotInComment[key] = value + if key in Dict: + err('%s:%r: warning: overriding: %r %r\n' % (substfile, lineno, key, value)) + err('%s:%r: warning: previous: %r\n' % (substfile, lineno, Dict[key])) + Dict[key] = value + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/fixdiv.py b/marketing/Tools/scripts/fixdiv.py new file mode 100644 index 0000000000000000000000000000000000000000..df7c481aa228083db7b87dd488f892786e4634e2 --- /dev/null +++ b/marketing/Tools/scripts/fixdiv.py @@ -0,0 +1,378 @@ +#! /usr/bin/env python3 + +"""fixdiv - tool to fix division operators. + +To use this tool, first run `python -Qwarnall yourscript.py 2>warnings'. +This runs the script `yourscript.py' while writing warning messages +about all uses of the classic division operator to the file +`warnings'. The warnings look like this: + + :: DeprecationWarning: classic division + +The warnings are written to stderr, so you must use `2>' for the I/O +redirect. I know of no way to redirect stderr on Windows in a DOS +box, so you will have to modify the script to set sys.stderr to some +kind of log file if you want to do this on Windows. + +The warnings are not limited to the script; modules imported by the +script may also trigger warnings. In fact a useful technique is to +write a test script specifically intended to exercise all code in a +particular module or set of modules. + +Then run `python fixdiv.py warnings'. This first reads the warnings, +looking for classic division warnings, and sorts them by file name and +line number. Then, for each file that received at least one warning, +it parses the file and tries to match the warnings up to the division +operators found in the source code. If it is successful, it writes +its findings to stdout, preceded by a line of dashes and a line of the +form: + + Index: + +If the only findings found are suggestions to change a / operator into +a // operator, the output is acceptable input for the Unix 'patch' +program. + +Here are the possible messages on stdout (N stands for a line number): + +- A plain-diff-style change ('NcN', a line marked by '<', a line + containing '---', and a line marked by '>'): + + A / operator was found that should be changed to //. This is the + recommendation when only int and/or long arguments were seen. + +- 'True division / operator at line N' and a line marked by '=': + + A / operator was found that can remain unchanged. This is the + recommendation when only float and/or complex arguments were seen. + +- 'Ambiguous / operator (..., ...) at line N', line marked by '?': + + A / operator was found for which int or long as well as float or + complex arguments were seen. This is highly unlikely; if it occurs, + you may have to restructure the code to keep the classic semantics, + or maybe you don't care about the classic semantics. + +- 'No conclusive evidence on line N', line marked by '*': + + A / operator was found for which no warnings were seen. This could + be code that was never executed, or code that was only executed + with user-defined objects as arguments. You will have to + investigate further. Note that // can be overloaded separately from + /, using __floordiv__. True division can also be separately + overloaded, using __truediv__. Classic division should be the same + as either of those. (XXX should I add a warning for division on + user-defined objects, to disambiguate this case from code that was + never executed?) + +- 'Phantom ... warnings for line N', line marked by '*': + + A warning was seen for a line not containing a / operator. The most + likely cause is a warning about code executed by 'exec' or eval() + (see note below), or an indirect invocation of the / operator, for + example via the div() function in the operator module. It could + also be caused by a change to the file between the time the test + script was run to collect warnings and the time fixdiv was run. + +- 'More than one / operator in line N'; or + 'More than one / operator per statement in lines N-N': + + The scanner found more than one / operator on a single line, or in a + statement split across multiple lines. Because the warnings + framework doesn't (and can't) show the offset within the line, and + the code generator doesn't always give the correct line number for + operations in a multi-line statement, we can't be sure whether all + operators in the statement were executed. To be on the safe side, + by default a warning is issued about this case. In practice, these + cases are usually safe, and the -m option suppresses these warning. + +- 'Can't find the / operator in line N', line marked by '*': + + This really shouldn't happen. It means that the tokenize module + reported a '/' operator but the line it returns didn't contain a '/' + character at the indicated position. + +- 'Bad warning for line N: XYZ', line marked by '*': + + This really shouldn't happen. It means that a 'classic XYZ + division' warning was read with XYZ being something other than + 'int', 'long', 'float', or 'complex'. + +Notes: + +- The augmented assignment operator /= is handled the same way as the + / operator. + +- This tool never looks at the // operator; no warnings are ever + generated for use of this operator. + +- This tool never looks at the / operator when a future division + statement is in effect; no warnings are generated in this case, and + because the tool only looks at files for which at least one classic + division warning was seen, it will never look at files containing a + future division statement. + +- Warnings may be issued for code not read from a file, but executed + using the exec() or eval() functions. These may have + in the filename position, in which case the fixdiv script + will attempt and fail to open a file named '' and issue a + warning about this failure; or these may be reported as 'Phantom' + warnings (see above). You're on your own to deal with these. You + could make all recommended changes and add a future division + statement to all affected files, and then re-run the test script; it + should not issue any warnings. If there are any, and you have a + hard time tracking down where they are generated, you can use the + -Werror option to force an error instead of a first warning, + generating a traceback. + +- The tool should be run from the same directory as that from which + the original script was run, otherwise it won't be able to open + files given by relative pathnames. +""" + +import sys +import getopt +import re +import tokenize + +multi_ok = 0 + +def main(): + try: + opts, args = getopt.getopt(sys.argv[1:], "hm") + except getopt.error as msg: + usage(msg) + return 2 + for o, a in opts: + if o == "-h": + print(__doc__) + return + if o == "-m": + global multi_ok + multi_ok = 1 + if not args: + usage("at least one file argument is required") + return 2 + if args[1:]: + sys.stderr.write("%s: extra file arguments ignored\n", sys.argv[0]) + warnings = readwarnings(args[0]) + if warnings is None: + return 1 + files = list(warnings.keys()) + if not files: + print("No classic division warnings read from", args[0]) + return + files.sort() + exit = None + for filename in files: + x = process(filename, warnings[filename]) + exit = exit or x + return exit + +def usage(msg): + sys.stderr.write("%s: %s\n" % (sys.argv[0], msg)) + sys.stderr.write("Usage: %s [-m] warnings\n" % sys.argv[0]) + sys.stderr.write("Try `%s -h' for more information.\n" % sys.argv[0]) + +PATTERN = (r"^(.+?):(\d+): DeprecationWarning: " + r"classic (int|long|float|complex) division$") + +def readwarnings(warningsfile): + prog = re.compile(PATTERN) + warnings = {} + try: + f = open(warningsfile) + except IOError as msg: + sys.stderr.write("can't open: %s\n" % msg) + return + with f: + while 1: + line = f.readline() + if not line: + break + m = prog.match(line) + if not m: + if line.find("division") >= 0: + sys.stderr.write("Warning: ignored input " + line) + continue + filename, lineno, what = m.groups() + list = warnings.get(filename) + if list is None: + warnings[filename] = list = [] + list.append((int(lineno), sys.intern(what))) + return warnings + +def process(filename, list): + print("-"*70) + assert list # if this fails, readwarnings() is broken + try: + fp = open(filename) + except IOError as msg: + sys.stderr.write("can't open: %s\n" % msg) + return 1 + with fp: + print("Index:", filename) + f = FileContext(fp) + list.sort() + index = 0 # list[:index] has been processed, list[index:] is still to do + g = tokenize.generate_tokens(f.readline) + while 1: + startlineno, endlineno, slashes = lineinfo = scanline(g) + if startlineno is None: + break + assert startlineno <= endlineno is not None + orphans = [] + while index < len(list) and list[index][0] < startlineno: + orphans.append(list[index]) + index += 1 + if orphans: + reportphantomwarnings(orphans, f) + warnings = [] + while index < len(list) and list[index][0] <= endlineno: + warnings.append(list[index]) + index += 1 + if not slashes and not warnings: + pass + elif slashes and not warnings: + report(slashes, "No conclusive evidence") + elif warnings and not slashes: + reportphantomwarnings(warnings, f) + else: + if len(slashes) > 1: + if not multi_ok: + rows = [] + lastrow = None + for (row, col), line in slashes: + if row == lastrow: + continue + rows.append(row) + lastrow = row + assert rows + if len(rows) == 1: + print("*** More than one / operator in line", rows[0]) + else: + print("*** More than one / operator per statement", end=' ') + print("in lines %d-%d" % (rows[0], rows[-1])) + intlong = [] + floatcomplex = [] + bad = [] + for lineno, what in warnings: + if what in ("int", "long"): + intlong.append(what) + elif what in ("float", "complex"): + floatcomplex.append(what) + else: + bad.append(what) + lastrow = None + for (row, col), line in slashes: + if row == lastrow: + continue + lastrow = row + line = chop(line) + if line[col:col+1] != "/": + print("*** Can't find the / operator in line %d:" % row) + print("*", line) + continue + if bad: + print("*** Bad warning for line %d:" % row, bad) + print("*", line) + elif intlong and not floatcomplex: + print("%dc%d" % (row, row)) + print("<", line) + print("---") + print(">", line[:col] + "/" + line[col:]) + elif floatcomplex and not intlong: + print("True division / operator at line %d:" % row) + print("=", line) + elif intlong and floatcomplex: + print("*** Ambiguous / operator (%s, %s) at line %d:" % + ("|".join(intlong), "|".join(floatcomplex), row)) + print("?", line) + +def reportphantomwarnings(warnings, f): + blocks = [] + lastrow = None + lastblock = None + for row, what in warnings: + if row != lastrow: + lastblock = [row] + blocks.append(lastblock) + lastblock.append(what) + for block in blocks: + row = block[0] + whats = "/".join(block[1:]) + print("*** Phantom %s warnings for line %d:" % (whats, row)) + f.report(row, mark="*") + +def report(slashes, message): + lastrow = None + for (row, col), line in slashes: + if row != lastrow: + print("*** %s on line %d:" % (message, row)) + print("*", chop(line)) + lastrow = row + +class FileContext: + def __init__(self, fp, window=5, lineno=1): + self.fp = fp + self.window = 5 + self.lineno = 1 + self.eoflookahead = 0 + self.lookahead = [] + self.buffer = [] + def fill(self): + while len(self.lookahead) < self.window and not self.eoflookahead: + line = self.fp.readline() + if not line: + self.eoflookahead = 1 + break + self.lookahead.append(line) + def readline(self): + self.fill() + if not self.lookahead: + return "" + line = self.lookahead.pop(0) + self.buffer.append(line) + self.lineno += 1 + return line + def __getitem__(self, index): + self.fill() + bufstart = self.lineno - len(self.buffer) + lookend = self.lineno + len(self.lookahead) + if bufstart <= index < self.lineno: + return self.buffer[index - bufstart] + if self.lineno <= index < lookend: + return self.lookahead[index - self.lineno] + raise KeyError + def report(self, first, last=None, mark="*"): + if last is None: + last = first + for i in range(first, last+1): + try: + line = self[first] + except KeyError: + line = "" + print(mark, chop(line)) + +def scanline(g): + slashes = [] + startlineno = None + endlineno = None + for type, token, start, end, line in g: + endlineno = end[0] + if startlineno is None: + startlineno = endlineno + if token in ("/", "/="): + slashes.append((start, line)) + if type == tokenize.NEWLINE: + break + return startlineno, endlineno, slashes + +def chop(line): + if line.endswith("\n"): + return line[:-1] + else: + return line + +if __name__ == "__main__": + sys.exit(main()) diff --git a/marketing/Tools/scripts/fixheader.py b/marketing/Tools/scripts/fixheader.py new file mode 100644 index 0000000000000000000000000000000000000000..c834eec1e20e6008c76e049ba86dfa46b7e64276 --- /dev/null +++ b/marketing/Tools/scripts/fixheader.py @@ -0,0 +1,49 @@ +#! /usr/bin/env python3 + +# Add some standard cpp magic to a header file + +import sys + +def main(): + args = sys.argv[1:] + for filename in args: + process(filename) + +def process(filename): + try: + f = open(filename, 'r') + except IOError as msg: + sys.stderr.write('%s: can\'t open: %s\n' % (filename, str(msg))) + return + with f: + data = f.read() + if data[:2] != '/*': + sys.stderr.write('%s does not begin with C comment\n' % filename) + return + try: + f = open(filename, 'w') + except IOError as msg: + sys.stderr.write('%s: can\'t write: %s\n' % (filename, str(msg))) + return + with f: + sys.stderr.write('Processing %s ...\n' % filename) + magic = 'Py_' + for c in filename: + if ord(c)<=0x80 and c.isalnum(): + magic = magic + c.upper() + else: magic = magic + '_' + print('#ifndef', magic, file=f) + print('#define', magic, file=f) + print('#ifdef __cplusplus', file=f) + print('extern "C" {', file=f) + print('#endif', file=f) + print(file=f) + f.write(data) + print(file=f) + print('#ifdef __cplusplus', file=f) + print('}', file=f) + print('#endif', file=f) + print('#endif /*', '!'+magic, '*/', file=f) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/fixnotice.py b/marketing/Tools/scripts/fixnotice.py new file mode 100644 index 0000000000000000000000000000000000000000..317051dd82f3e9b8e7f928acd3c65ebbf9e21928 --- /dev/null +++ b/marketing/Tools/scripts/fixnotice.py @@ -0,0 +1,109 @@ +#! /usr/bin/env python3 + +"""(Ostensibly) fix copyright notices in files. + +Actually, this script will simply replace a block of text in a file from one +string to another. It will only do this once though, i.e. not globally +throughout the file. It writes a backup file and then does an os.rename() +dance for atomicity. + +Usage: fixnotices.py [options] [filenames] +Options: + -h / --help + Print this message and exit + + --oldnotice=file + Use the notice in the file as the old (to be replaced) string, instead + of the hard coded value in the script. + + --newnotice=file + Use the notice in the file as the new (replacement) string, instead of + the hard coded value in the script. + + --dry-run + Don't actually make the changes, but print out the list of files that + would change. When used with -v, a status will be printed for every + file. + + -v / --verbose + Print a message for every file looked at, indicating whether the file + is changed or not. +""" + +OLD_NOTICE = """/*********************************************************** +Copyright (c) 2000, BeOpen.com. +Copyright (c) 1995-2000, Corporation for National Research Initiatives. +Copyright (c) 1990-1995, Stichting Mathematisch Centrum. +All rights reserved. + +See the file "Misc/COPYRIGHT" for information on usage and +redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. +******************************************************************/ +""" +import os +import sys +import getopt + +NEW_NOTICE = "" +DRYRUN = 0 +VERBOSE = 0 + + +def usage(code, msg=''): + print(__doc__ % globals()) + if msg: + print(msg) + sys.exit(code) + + +def main(): + global DRYRUN, OLD_NOTICE, NEW_NOTICE, VERBOSE + try: + opts, args = getopt.getopt(sys.argv[1:], 'hv', + ['help', 'oldnotice=', 'newnotice=', + 'dry-run', 'verbose']) + except getopt.error as msg: + usage(1, msg) + + for opt, arg in opts: + if opt in ('-h', '--help'): + usage(0) + elif opt in ('-v', '--verbose'): + VERBOSE = 1 + elif opt == '--dry-run': + DRYRUN = 1 + elif opt == '--oldnotice': + with open(arg) as fp: + OLD_NOTICE = fp.read() + elif opt == '--newnotice': + with open(arg) as fp: + NEW_NOTICE = fp.read() + + for arg in args: + process(arg) + + +def process(file): + with open(file) as f: + data = f.read() + i = data.find(OLD_NOTICE) + if i < 0: + if VERBOSE: + print('no change:', file) + return + elif DRYRUN or VERBOSE: + print(' change:', file) + if DRYRUN: + # Don't actually change the file + return + data = data[:i] + NEW_NOTICE + data[i+len(OLD_NOTICE):] + new = file + ".new" + backup = file + ".bak" + with open(new, "w") as f: + f.write(data) + os.rename(file, backup) + os.rename(new, file) + + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/fixps.py b/marketing/Tools/scripts/fixps.py new file mode 100644 index 0000000000000000000000000000000000000000..725300e56a27db4a7a413b11cd074210c51881eb --- /dev/null +++ b/marketing/Tools/scripts/fixps.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python3 + +# Fix Python script(s) to reference the interpreter via /usr/bin/env python. +# Warning: this overwrites the file without making a backup. + +import sys +import re + + +def main(): + for filename in sys.argv[1:]: + try: + f = open(filename, 'r') + except IOError as msg: + print(filename, ': can\'t open :', msg) + continue + with f: + line = f.readline() + if not re.match('^#! */usr/local/bin/python', line): + print(filename, ': not a /usr/local/bin/python script') + continue + rest = f.read() + line = re.sub('/usr/local/bin/python', + '/usr/bin/env python', line) + print(filename, ':', repr(line)) + with open(filename, "w") as f: + f.write(line) + f.write(rest) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/generate_opcode_h.py b/marketing/Tools/scripts/generate_opcode_h.py new file mode 100644 index 0000000000000000000000000000000000000000..873f82156e217bf25038c45ac2d3534144de267f --- /dev/null +++ b/marketing/Tools/scripts/generate_opcode_h.py @@ -0,0 +1,58 @@ +# This script generates the opcode.h header file. + +import sys +import tokenize + +header = """ +/* Auto-generated by Tools/scripts/generate_opcode_h.py from Lib/opcode.py */ +#ifndef Py_OPCODE_H +#define Py_OPCODE_H +#ifdef __cplusplus +extern "C" { +#endif + + + /* Instruction opcodes for compiled code */ +""".lstrip() + +footer = """ +/* EXCEPT_HANDLER is a special, implicit block type which is created when + entering an except handler. It is not an opcode but we define it here + as we want it to be available to both frameobject.c and ceval.c, while + remaining private.*/ +#define EXCEPT_HANDLER 257 + +#define HAS_ARG(op) ((op) >= HAVE_ARGUMENT) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_OPCODE_H */ +""" + + +def main(opcode_py, outfile='Include/opcode.h'): + opcode = {} + if hasattr(tokenize, 'open'): + fp = tokenize.open(opcode_py) # Python 3.2+ + else: + fp = open(opcode_py) # Python 2.7 + with fp: + code = fp.read() + exec(code, opcode) + opmap = opcode['opmap'] + with open(outfile, 'w') as fobj: + fobj.write(header) + for name in opcode['opname']: + if name in opmap: + fobj.write("#define %-23s %3s\n" % (name, opmap[name])) + if name == 'POP_EXCEPT': # Special entry for HAVE_ARGUMENT + fobj.write("#define %-23s %3d\n" % + ('HAVE_ARGUMENT', opcode['HAVE_ARGUMENT'])) + fobj.write(footer) + + print("%s regenerated from %s" % (outfile, opcode_py)) + + +if __name__ == '__main__': + main(sys.argv[1], sys.argv[2]) diff --git a/marketing/Tools/scripts/generate_symbol_py.py b/marketing/Tools/scripts/generate_symbol_py.py new file mode 100644 index 0000000000000000000000000000000000000000..9219b096e4d67d5993e861e46cce2d7e7f1b318f --- /dev/null +++ b/marketing/Tools/scripts/generate_symbol_py.py @@ -0,0 +1,53 @@ +#! /usr/bin/env python3 +# This script generates the symbol.py source file. + +import sys +import re + +def main(inFileName="Include/graminit.h", outFileName="Lib/symbol.py"): + try: + fp = open(inFileName) + except OSError as err: + sys.stderr.write("I/O error: %s\n" % str(err)) + sys.exit(1) + with fp: + lines = fp.read().split("\n") + prog = re.compile( + "#define[ \t][ \t]*([A-Z0-9][A-Z0-9_]*)[ \t][ \t]*([0-9][0-9]*)", + re.IGNORECASE) + tokens = {} + for line in lines: + match = prog.match(line) + if match: + name, val = match.group(1, 2) + val = int(val) + tokens[val] = name # reverse so we can sort them... + keys = sorted(tokens.keys()) + # load the output skeleton from the target: + try: + fp = open(outFileName) + except OSError as err: + sys.stderr.write("I/O error: %s\n" % str(err)) + sys.exit(2) + with fp: + format = fp.read().split("\n") + try: + start = format.index("#--start constants--") + 1 + end = format.index("#--end constants--") + except ValueError: + sys.stderr.write("target does not contain format markers") + sys.exit(3) + lines = [] + for val in keys: + lines.append("%s = %d" % (tokens[val], val)) + format[start:end] = lines + try: + fp = open(outFileName, 'w') + except OSError as err: + sys.stderr.write("I/O error: %s\n" % str(err)) + sys.exit(4) + with fp: + fp.write("\n".join(format)) + +if __name__ == '__main__': + main(*sys.argv[1:]) diff --git a/marketing/Tools/scripts/generate_token.py b/marketing/Tools/scripts/generate_token.py new file mode 100644 index 0000000000000000000000000000000000000000..77bb5bd5eca02c1dc5482eb7319559d113d38cc3 --- /dev/null +++ b/marketing/Tools/scripts/generate_token.py @@ -0,0 +1,272 @@ +#! /usr/bin/env python3 +# This script generates token related files from Grammar/Tokens: +# +# Doc/library/token-list.inc +# Include/token.h +# Parser/token.c +# Lib/token.py + + +NT_OFFSET = 256 + +def load_tokens(path): + tok_names = [] + string_to_tok = {} + ERRORTOKEN = None + with open(path) as fp: + for line in fp: + line = line.strip() + # strip comments + i = line.find('#') + if i >= 0: + line = line[:i].strip() + if not line: + continue + fields = line.split() + name = fields[0] + value = len(tok_names) + if name == 'ERRORTOKEN': + ERRORTOKEN = value + string = fields[1] if len(fields) > 1 else None + if string: + string = eval(string) + string_to_tok[string] = value + tok_names.append(name) + return tok_names, ERRORTOKEN, string_to_tok + + +def update_file(file, content): + try: + with open(file, 'r') as fobj: + if fobj.read() == content: + return False + except (OSError, ValueError): + pass + with open(file, 'w') as fobj: + fobj.write(content) + return True + + +token_h_template = """\ +/* Auto-generated by Tools/scripts/generate_token.py */ + +/* Token types */ +#ifndef Py_LIMITED_API +#ifndef Py_TOKEN_H +#define Py_TOKEN_H +#ifdef __cplusplus +extern "C" { +#endif + +#undef TILDE /* Prevent clash of our definition with system macro. Ex AIX, ioctl.h */ + +%s\ +#define N_TOKENS %d +#define NT_OFFSET %d + +/* Special definitions for cooperation with parser */ + +#define ISTERMINAL(x) ((x) < NT_OFFSET) +#define ISNONTERMINAL(x) ((x) >= NT_OFFSET) +#define ISEOF(x) ((x) == ENDMARKER) +#define ISWHITESPACE(x) ((x) == ENDMARKER || \\ + (x) == NEWLINE || \\ + (x) == INDENT || \\ + (x) == DEDENT) + + +PyAPI_DATA(const char * const) _PyParser_TokenNames[]; /* Token names */ +PyAPI_FUNC(int) PyToken_OneChar(int); +PyAPI_FUNC(int) PyToken_TwoChars(int, int); +PyAPI_FUNC(int) PyToken_ThreeChars(int, int, int); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_TOKEN_H */ +#endif /* Py_LIMITED_API */ +""" + +def make_h(infile, outfile='Include/token.h'): + tok_names, ERRORTOKEN, string_to_tok = load_tokens(infile) + + defines = [] + for value, name in enumerate(tok_names[:ERRORTOKEN + 1]): + defines.append("#define %-15s %d\n" % (name, value)) + + if update_file(outfile, token_h_template % ( + ''.join(defines), + len(tok_names), + NT_OFFSET + )): + print("%s regenerated from %s" % (outfile, infile)) + + +token_c_template = """\ +/* Auto-generated by Tools/scripts/generate_token.py */ + +#include "Python.h" +#include "token.h" + +/* Token names */ + +const char * const _PyParser_TokenNames[] = { +%s\ +}; + +/* Return the token corresponding to a single character */ + +int +PyToken_OneChar(int c1) +{ +%s\ + return OP; +} + +int +PyToken_TwoChars(int c1, int c2) +{ +%s\ + return OP; +} + +int +PyToken_ThreeChars(int c1, int c2, int c3) +{ +%s\ + return OP; +} +""" + +def generate_chars_to_token(mapping, n=1): + result = [] + write = result.append + indent = ' ' * n + write(indent) + write('switch (c%d) {\n' % (n,)) + for c in sorted(mapping): + write(indent) + value = mapping[c] + if isinstance(value, dict): + write("case '%s':\n" % (c,)) + write(generate_chars_to_token(value, n + 1)) + write(indent) + write(' break;\n') + else: + write("case '%s': return %s;\n" % (c, value)) + write(indent) + write('}\n') + return ''.join(result) + +def make_c(infile, outfile='Parser/token.c'): + tok_names, ERRORTOKEN, string_to_tok = load_tokens(infile) + string_to_tok['<>'] = string_to_tok['!='] + chars_to_token = {} + for string, value in string_to_tok.items(): + assert 1 <= len(string) <= 3 + name = tok_names[value] + m = chars_to_token.setdefault(len(string), {}) + for c in string[:-1]: + m = m.setdefault(c, {}) + m[string[-1]] = name + + names = [] + for value, name in enumerate(tok_names): + if value >= ERRORTOKEN: + name = '<%s>' % name + names.append(' "%s",\n' % name) + names.append(' "",\n') + + if update_file(outfile, token_c_template % ( + ''.join(names), + generate_chars_to_token(chars_to_token[1]), + generate_chars_to_token(chars_to_token[2]), + generate_chars_to_token(chars_to_token[3]) + )): + print("%s regenerated from %s" % (outfile, infile)) + + +token_inc_template = """\ +.. Auto-generated by Tools/scripts/generate_token.py +%s +.. data:: N_TOKENS + +.. data:: NT_OFFSET +""" + +def make_rst(infile, outfile='Doc/library/token-list.inc'): + tok_names, ERRORTOKEN, string_to_tok = load_tokens(infile) + tok_to_string = {value: s for s, value in string_to_tok.items()} + + names = [] + for value, name in enumerate(tok_names[:ERRORTOKEN + 1]): + names.append('.. data:: %s' % (name,)) + if value in tok_to_string: + names.append('') + names.append(' Token value for ``"%s"``.' % tok_to_string[value]) + names.append('') + + if update_file(outfile, token_inc_template % '\n'.join(names)): + print("%s regenerated from %s" % (outfile, infile)) + + +token_py_template = '''\ +"""Token constants.""" +# Auto-generated by Tools/scripts/generate_token.py + +__all__ = ['tok_name', 'ISTERMINAL', 'ISNONTERMINAL', 'ISEOF'] + +%s +N_TOKENS = %d +# Special definitions for cooperation with parser +NT_OFFSET = %d + +tok_name = {value: name + for name, value in globals().items() + if isinstance(value, int) and not name.startswith('_')} +__all__.extend(tok_name.values()) + +EXACT_TOKEN_TYPES = { +%s +} + +def ISTERMINAL(x): + return x < NT_OFFSET + +def ISNONTERMINAL(x): + return x >= NT_OFFSET + +def ISEOF(x): + return x == ENDMARKER +''' + +def make_py(infile, outfile='Lib/token.py'): + tok_names, ERRORTOKEN, string_to_tok = load_tokens(infile) + + constants = [] + for value, name in enumerate(tok_names): + constants.append('%s = %d' % (name, value)) + constants.insert(ERRORTOKEN, + "# These aren't used by the C tokenizer but are needed for tokenize.py") + + token_types = [] + for s, value in sorted(string_to_tok.items()): + token_types.append(' %r: %s,' % (s, tok_names[value])) + + if update_file(outfile, token_py_template % ( + '\n'.join(constants), + len(tok_names), + NT_OFFSET, + '\n'.join(token_types), + )): + print("%s regenerated from %s" % (outfile, infile)) + + +def main(op, infile='Grammar/Tokens', *args): + make = globals()['make_' + op] + make(infile, *args) + + +if __name__ == '__main__': + import sys + main(*sys.argv[1:]) diff --git a/marketing/Tools/scripts/get-remote-certificate.py b/marketing/Tools/scripts/get-remote-certificate.py new file mode 100644 index 0000000000000000000000000000000000000000..68272fca83fe27b61d5dafef3c21c2125a7b29c6 --- /dev/null +++ b/marketing/Tools/scripts/get-remote-certificate.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python3 +# +# fetch the certificate that the server(s) are providing in PEM form +# +# args are HOST:PORT [, HOST:PORT...] +# +# By Bill Janssen. + +import re +import os +import sys +import tempfile + + +def fetch_server_certificate (host, port): + + def subproc(cmd): + from subprocess import Popen, PIPE, STDOUT, DEVNULL + proc = Popen(cmd, stdout=PIPE, stderr=STDOUT, stdin=DEVNULL) + status = proc.wait() + output = proc.stdout.read() + return status, output + + def strip_to_x509_cert(certfile_contents, outfile=None): + m = re.search(br"^([-]+BEGIN CERTIFICATE[-]+[\r]*\n" + br".*[\r]*^[-]+END CERTIFICATE[-]+)$", + certfile_contents, re.MULTILINE | re.DOTALL) + if not m: + return None + else: + tn = tempfile.mktemp() + with open(tn, "wb") as fp: + fp.write(m.group(1) + b"\n") + try: + tn2 = (outfile or tempfile.mktemp()) + cmd = ['openssl', 'x509', '-in', tn, '-out', tn2] + status, output = subproc(cmd) + if status != 0: + raise RuntimeError('OpenSSL x509 failed with status %s and ' + 'output: %r' % (status, output)) + with open(tn2, 'rb') as fp: + data = fp.read() + os.unlink(tn2) + return data + finally: + os.unlink(tn) + + cmd = ['openssl', 's_client', '-connect', '%s:%s' % (host, port), '-showcerts'] + status, output = subproc(cmd) + + if status != 0: + raise RuntimeError('OpenSSL connect failed with status %s and ' + 'output: %r' % (status, output)) + certtext = strip_to_x509_cert(output) + if not certtext: + raise ValueError("Invalid response received from server at %s:%s" % + (host, port)) + return certtext + + +if __name__ == "__main__": + if len(sys.argv) < 2: + sys.stderr.write( + "Usage: %s HOSTNAME:PORTNUMBER [, HOSTNAME:PORTNUMBER...]\n" % + sys.argv[0]) + sys.exit(1) + for arg in sys.argv[1:]: + host, port = arg.split(":") + sys.stdout.buffer.write(fetch_server_certificate(host, int(port))) + sys.exit(0) diff --git a/marketing/Tools/scripts/google.py b/marketing/Tools/scripts/google.py new file mode 100644 index 0000000000000000000000000000000000000000..82fb2871885d03fd417e2705f58f1aed4a194676 --- /dev/null +++ b/marketing/Tools/scripts/google.py @@ -0,0 +1,25 @@ +#! /usr/bin/env python3 + +"""Script to search with Google + +Usage: + python3 google.py [search terms] +""" + +import sys +import urllib.parse +import webbrowser + + +def main(args): + def quote(arg): + if ' ' in arg: + arg = '"%s"' % arg + return urllib.parse.quote_plus(arg) + + qstring = '+'.join(quote(arg) for arg in args) + url = urllib.parse.urljoin('https://www.google.com/search', '?q=' + qstring) + webbrowser.open(url) + +if __name__ == '__main__': + main(sys.argv[1:]) diff --git a/marketing/Tools/scripts/gprof2html.py b/marketing/Tools/scripts/gprof2html.py new file mode 100644 index 0000000000000000000000000000000000000000..b14def4ef8482bef070bb7f21d8cff1af6bbc2b5 --- /dev/null +++ b/marketing/Tools/scripts/gprof2html.py @@ -0,0 +1,87 @@ +#! /usr/bin/env python3 + +"""Transform gprof(1) output into useful HTML.""" + +import html +import os +import re +import sys +import webbrowser + +header = """\ + + + gprof output (%s) + + +
+"""
+
+trailer = """\
+
+ + +""" + +def add_escapes(filename): + with open(filename) as fp: + for line in fp: + yield html.escape(line) + +def gprof2html(input, output, filename): + output.write(header % filename) + for line in input: + output.write(line) + if line.startswith(" time"): + break + labels = {} + for line in input: + m = re.match(r"(.* )(\w+)\n", line) + if not m: + output.write(line) + break + stuff, fname = m.group(1, 2) + labels[fname] = fname + output.write('%s%s\n' % + (stuff, fname, fname, fname)) + for line in input: + output.write(line) + if line.startswith("index % time"): + break + for line in input: + m = re.match(r"(.* )(\w+)(( <cycle.*>)? \[\d+\])\n", line) + if not m: + output.write(line) + if line.startswith("Index by function name"): + break + continue + prefix, fname, suffix = m.group(1, 2, 3) + if fname not in labels: + output.write(line) + continue + if line.startswith("["): + output.write('%s%s%s\n' % + (prefix, fname, fname, fname, suffix)) + else: + output.write('%s%s%s\n' % + (prefix, fname, fname, suffix)) + for line in input: + for part in re.findall(r"(\w+(?:\.c)?|\W+)", line): + if part in labels: + part = '%s' % (part, part) + output.write(part) + output.write(trailer) + + +def main(): + filename = "gprof.out" + if sys.argv[1:]: + filename = sys.argv[1] + outputfilename = filename + ".html" + input = add_escapes(filename) + with open(outputfilename, "w") as output: + gprof2html(input, output, filename) + webbrowser.open("file:" + os.path.abspath(outputfilename)) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/highlight.py b/marketing/Tools/scripts/highlight.py new file mode 100644 index 0000000000000000000000000000000000000000..9272fee4ee3b9df4410e192ff9a2b8de9ab82ebe --- /dev/null +++ b/marketing/Tools/scripts/highlight.py @@ -0,0 +1,265 @@ +#!/usr/bin/env python3 +'''Add syntax highlighting to Python source code''' + +__author__ = 'Raymond Hettinger' + +import builtins +import functools +import html as html_module +import keyword +import re +import tokenize + +#### Analyze Python Source ################################# + +def is_builtin(s): + 'Return True if s is the name of a builtin' + return hasattr(builtins, s) + +def combine_range(lines, start, end): + 'Join content from a range of lines between start and end' + (srow, scol), (erow, ecol) = start, end + if srow == erow: + return lines[srow-1][scol:ecol], end + rows = [lines[srow-1][scol:]] + lines[srow: erow-1] + [lines[erow-1][:ecol]] + return ''.join(rows), end + +def analyze_python(source): + '''Generate and classify chunks of Python for syntax highlighting. + Yields tuples in the form: (category, categorized_text). + ''' + lines = source.splitlines(True) + lines.append('') + readline = functools.partial(next, iter(lines), '') + kind = tok_str = '' + tok_type = tokenize.COMMENT + written = (1, 0) + for tok in tokenize.generate_tokens(readline): + prev_tok_type, prev_tok_str = tok_type, tok_str + tok_type, tok_str, (srow, scol), (erow, ecol), logical_lineno = tok + kind = '' + if tok_type == tokenize.COMMENT: + kind = 'comment' + elif tok_type == tokenize.OP and tok_str[:1] not in '{}[](),.:;@': + kind = 'operator' + elif tok_type == tokenize.STRING: + kind = 'string' + if prev_tok_type == tokenize.INDENT or scol==0: + kind = 'docstring' + elif tok_type == tokenize.NAME: + if tok_str in ('def', 'class', 'import', 'from'): + kind = 'definition' + elif prev_tok_str in ('def', 'class'): + kind = 'defname' + elif keyword.iskeyword(tok_str): + kind = 'keyword' + elif is_builtin(tok_str) and prev_tok_str != '.': + kind = 'builtin' + if kind: + text, written = combine_range(lines, written, (srow, scol)) + yield '', text + text, written = tok_str, (erow, ecol) + yield kind, text + line_upto_token, written = combine_range(lines, written, (erow, ecol)) + yield '', line_upto_token + +#### Raw Output ########################################### + +def raw_highlight(classified_text): + 'Straight text display of text classifications' + result = [] + for kind, text in classified_text: + result.append('%15s: %r\n' % (kind or 'plain', text)) + return ''.join(result) + +#### ANSI Output ########################################### + +default_ansi = { + 'comment': ('\033[0;31m', '\033[0m'), + 'string': ('\033[0;32m', '\033[0m'), + 'docstring': ('\033[0;32m', '\033[0m'), + 'keyword': ('\033[0;33m', '\033[0m'), + 'builtin': ('\033[0;35m', '\033[0m'), + 'definition': ('\033[0;33m', '\033[0m'), + 'defname': ('\033[0;34m', '\033[0m'), + 'operator': ('\033[0;33m', '\033[0m'), +} + +def ansi_highlight(classified_text, colors=default_ansi): + 'Add syntax highlighting to source code using ANSI escape sequences' + # http://en.wikipedia.org/wiki/ANSI_escape_code + result = [] + for kind, text in classified_text: + opener, closer = colors.get(kind, ('', '')) + result += [opener, text, closer] + return ''.join(result) + +#### HTML Output ########################################### + +def html_highlight(classified_text,opener='
\n', closer='
\n'): + 'Convert classified text to an HTML fragment' + result = [opener] + for kind, text in classified_text: + if kind: + result.append('' % kind) + result.append(html_module.escape(text)) + if kind: + result.append('') + result.append(closer) + return ''.join(result) + +default_css = { + '.comment': '{color: crimson;}', + '.string': '{color: forestgreen;}', + '.docstring': '{color: forestgreen; font-style:italic;}', + '.keyword': '{color: darkorange;}', + '.builtin': '{color: purple;}', + '.definition': '{color: darkorange; font-weight:bold;}', + '.defname': '{color: blue;}', + '.operator': '{color: brown;}', +} + +default_html = '''\ + + + + + {title} + + + +{body} + + +''' + +def build_html_page(classified_text, title='python', + css=default_css, html=default_html): + 'Create a complete HTML page with colorized source code' + css_str = '\n'.join(['%s %s' % item for item in css.items()]) + result = html_highlight(classified_text) + title = html_module.escape(title) + return html.format(title=title, css=css_str, body=result) + +#### LaTeX Output ########################################## + +default_latex_commands = { + 'comment': r'{\color{red}#1}', + 'string': r'{\color{ForestGreen}#1}', + 'docstring': r'{\emph{\color{ForestGreen}#1}}', + 'keyword': r'{\color{orange}#1}', + 'builtin': r'{\color{purple}#1}', + 'definition': r'{\color{orange}#1}', + 'defname': r'{\color{blue}#1}', + 'operator': r'{\color{brown}#1}', +} + +default_latex_document = r''' +\documentclass{article} +\usepackage{alltt} +\usepackage{upquote} +\usepackage{color} +\usepackage[usenames,dvipsnames]{xcolor} +\usepackage[cm]{fullpage} +%(macros)s +\begin{document} +\center{\LARGE{%(title)s}} +\begin{alltt} +%(body)s +\end{alltt} +\end{document} +''' + +def alltt_escape(s): + 'Replace backslash and braces with their escaped equivalents' + xlat = {'{': r'\{', '}': r'\}', '\\': r'\textbackslash{}'} + return re.sub(r'[\\{}]', lambda mo: xlat[mo.group()], s) + +def latex_highlight(classified_text, title = 'python', + commands = default_latex_commands, + document = default_latex_document): + 'Create a complete LaTeX document with colorized source code' + macros = '\n'.join(r'\newcommand{\py%s}[1]{%s}' % c for c in commands.items()) + result = [] + for kind, text in classified_text: + if kind: + result.append(r'\py%s{' % kind) + result.append(alltt_escape(text)) + if kind: + result.append('}') + return default_latex_document % dict(title=title, macros=macros, body=''.join(result)) + + +if __name__ == '__main__': + import argparse + import os.path + import sys + import textwrap + import webbrowser + + parser = argparse.ArgumentParser( + description = 'Add syntax highlighting to Python source code', + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog = textwrap.dedent(''' + examples: + + # Show syntax highlighted code in the terminal window + $ ./highlight.py myfile.py + + # Colorize myfile.py and display in a browser + $ ./highlight.py -b myfile.py + + # Create an HTML section to embed in an existing webpage + ./highlight.py -s myfile.py + + # Create a complete HTML file + $ ./highlight.py -c myfile.py > myfile.html + + # Create a PDF using LaTeX + $ ./highlight.py -l myfile.py | pdflatex + + ''')) + parser.add_argument('sourcefile', metavar = 'SOURCEFILE', + help = 'file containing Python sourcecode') + parser.add_argument('-b', '--browser', action = 'store_true', + help = 'launch a browser to show results') + parser.add_argument('-c', '--complete', action = 'store_true', + help = 'build a complete html webpage') + parser.add_argument('-l', '--latex', action = 'store_true', + help = 'build a LaTeX document') + parser.add_argument('-r', '--raw', action = 'store_true', + help = 'raw parse of categorized text') + parser.add_argument('-s', '--section', action = 'store_true', + help = 'show an HTML section rather than a complete webpage') + args = parser.parse_args() + + if args.section and (args.browser or args.complete): + parser.error('The -s/--section option is incompatible with ' + 'the -b/--browser or -c/--complete options') + + sourcefile = args.sourcefile + with open(sourcefile) as f: + source = f.read() + classified_text = analyze_python(source) + + if args.raw: + encoded = raw_highlight(classified_text) + elif args.complete or args.browser: + encoded = build_html_page(classified_text, title=sourcefile) + elif args.section: + encoded = html_highlight(classified_text) + elif args.latex: + encoded = latex_highlight(classified_text, title=sourcefile) + else: + encoded = ansi_highlight(classified_text) + + if args.browser: + htmlfile = os.path.splitext(os.path.basename(sourcefile))[0] + '.html' + with open(htmlfile, 'w') as f: + f.write(encoded) + webbrowser.open('file://' + os.path.abspath(htmlfile)) + else: + sys.stdout.write(encoded) diff --git a/marketing/Tools/scripts/ifdef.py b/marketing/Tools/scripts/ifdef.py new file mode 100644 index 0000000000000000000000000000000000000000..22249b2d0af5dcc279acd49b3079951271252ec1 --- /dev/null +++ b/marketing/Tools/scripts/ifdef.py @@ -0,0 +1,111 @@ +#! /usr/bin/env python3 + +# Selectively preprocess #ifdef / #ifndef statements. +# Usage: +# ifdef [-Dname] ... [-Uname] ... [file] ... +# +# This scans the file(s), looking for #ifdef and #ifndef preprocessor +# commands that test for one of the names mentioned in the -D and -U +# options. On standard output it writes a copy of the input file(s) +# minus those code sections that are suppressed by the selected +# combination of defined/undefined symbols. The #if(n)def/#else/#else +# lines themselves (if the #if(n)def tests for one of the mentioned +# names) are removed as well. + +# Features: Arbitrary nesting of recognized and unrecognized +# preprocessor statements works correctly. Unrecognized #if* commands +# are left in place, so it will never remove too much, only too +# little. It does accept whitespace around the '#' character. + +# Restrictions: There should be no comments or other symbols on the +# #if(n)def lines. The effect of #define/#undef commands in the input +# file or in included files is not taken into account. Tests using +# #if and the defined() pseudo function are not recognized. The #elif +# command is not recognized. Improperly nesting is not detected. +# Lines that look like preprocessor commands but which are actually +# part of comments or string literals will be mistaken for +# preprocessor commands. + +import sys +import getopt + +defs = [] +undefs = [] + +def main(): + opts, args = getopt.getopt(sys.argv[1:], 'D:U:') + for o, a in opts: + if o == '-D': + defs.append(a) + if o == '-U': + undefs.append(a) + if not args: + args = ['-'] + for filename in args: + if filename == '-': + process(sys.stdin, sys.stdout) + else: + with open(filename) as f: + process(f, sys.stdout) + +def process(fpi, fpo): + keywords = ('if', 'ifdef', 'ifndef', 'else', 'endif') + ok = 1 + stack = [] + while 1: + line = fpi.readline() + if not line: break + while line[-2:] == '\\\n': + nextline = fpi.readline() + if not nextline: break + line = line + nextline + tmp = line.strip() + if tmp[:1] != '#': + if ok: fpo.write(line) + continue + tmp = tmp[1:].strip() + words = tmp.split() + keyword = words[0] + if keyword not in keywords: + if ok: fpo.write(line) + continue + if keyword in ('ifdef', 'ifndef') and len(words) == 2: + if keyword == 'ifdef': + ko = 1 + else: + ko = 0 + word = words[1] + if word in defs: + stack.append((ok, ko, word)) + if not ko: ok = 0 + elif word in undefs: + stack.append((ok, not ko, word)) + if ko: ok = 0 + else: + stack.append((ok, -1, word)) + if ok: fpo.write(line) + elif keyword == 'if': + stack.append((ok, -1, '')) + if ok: fpo.write(line) + elif keyword == 'else' and stack: + s_ok, s_ko, s_word = stack[-1] + if s_ko < 0: + if ok: fpo.write(line) + else: + s_ko = not s_ko + ok = s_ok + if not s_ko: ok = 0 + stack[-1] = s_ok, s_ko, s_word + elif keyword == 'endif' and stack: + s_ok, s_ko, s_word = stack[-1] + if s_ko < 0: + if ok: fpo.write(line) + del stack[-1] + ok = s_ok + else: + sys.stderr.write('Unknown keyword %s\n' % keyword) + if stack: + sys.stderr.write('stack: %s\n' % stack) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/import_diagnostics.py b/marketing/Tools/scripts/import_diagnostics.py new file mode 100644 index 0000000000000000000000000000000000000000..c907221d049c52947761b6b6eea903854e1e1d8d --- /dev/null +++ b/marketing/Tools/scripts/import_diagnostics.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 +"""Miscellaneous diagnostics for the import system""" + +import sys +import argparse +from pprint import pprint + +def _dump_state(args): + print(sys.version) + for name in args.attributes: + print("sys.{}:".format(name)) + pprint(getattr(sys, name)) + +def _add_dump_args(cmd): + cmd.add_argument("attributes", metavar="ATTR", nargs="+", + help="sys module attribute to display") + +COMMANDS = ( + ("dump", "Dump import state", _dump_state, _add_dump_args), +) + +def _make_parser(): + parser = argparse.ArgumentParser() + sub = parser.add_subparsers(title="Commands") + for name, description, implementation, add_args in COMMANDS: + cmd = sub.add_parser(name, help=description) + cmd.set_defaults(command=implementation) + add_args(cmd) + return parser + +def main(args): + parser = _make_parser() + args = parser.parse_args(args) + return args.command(args) + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/marketing/Tools/scripts/lfcr.py b/marketing/Tools/scripts/lfcr.py new file mode 100644 index 0000000000000000000000000000000000000000..bf8fe1c245ef4c0dda7c52247a11a42554f5ad39 --- /dev/null +++ b/marketing/Tools/scripts/lfcr.py @@ -0,0 +1,24 @@ +#! /usr/bin/env python3 + +"Replace LF with CRLF in argument files. Print names of changed files." + +import sys, re, os + +def main(): + for filename in sys.argv[1:]: + if os.path.isdir(filename): + print(filename, "Directory!") + continue + with open(filename, "rb") as f: + data = f.read() + if b'\0' in data: + print(filename, "Binary!") + continue + newdata = re.sub(b"\r?\n", b"\r\n", data) + if newdata != data: + print(filename) + with open(filename, "wb") as f: + f.write(newdata) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/linktree.py b/marketing/Tools/scripts/linktree.py new file mode 100644 index 0000000000000000000000000000000000000000..e83f198593ade13411210d8c96bd5ccda3067715 --- /dev/null +++ b/marketing/Tools/scripts/linktree.py @@ -0,0 +1,80 @@ +#! /usr/bin/env python3 + +# linktree +# +# Make a copy of a directory tree with symbolic links to all files in the +# original tree. +# All symbolic links go to a special symbolic link at the top, so you +# can easily fix things if the original source tree moves. +# See also "mkreal". +# +# usage: mklinks oldtree newtree + +import sys, os + +LINK = '.LINK' # Name of special symlink at the top. + +debug = 0 + +def main(): + if not 3 <= len(sys.argv) <= 4: + print('usage:', sys.argv[0], 'oldtree newtree [linkto]') + return 2 + oldtree, newtree = sys.argv[1], sys.argv[2] + if len(sys.argv) > 3: + link = sys.argv[3] + link_may_fail = 1 + else: + link = LINK + link_may_fail = 0 + if not os.path.isdir(oldtree): + print(oldtree + ': not a directory') + return 1 + try: + os.mkdir(newtree, 0o777) + except OSError as msg: + print(newtree + ': cannot mkdir:', msg) + return 1 + linkname = os.path.join(newtree, link) + try: + os.symlink(os.path.join(os.pardir, oldtree), linkname) + except OSError as msg: + if not link_may_fail: + print(linkname + ': cannot symlink:', msg) + return 1 + else: + print(linkname + ': warning: cannot symlink:', msg) + linknames(oldtree, newtree, link) + return 0 + +def linknames(old, new, link): + if debug: print('linknames', (old, new, link)) + try: + names = os.listdir(old) + except OSError as msg: + print(old + ': warning: cannot listdir:', msg) + return + for name in names: + if name not in (os.curdir, os.pardir): + oldname = os.path.join(old, name) + linkname = os.path.join(link, name) + newname = os.path.join(new, name) + if debug > 1: print(oldname, newname, linkname) + if os.path.isdir(oldname) and \ + not os.path.islink(oldname): + try: + os.mkdir(newname, 0o777) + ok = 1 + except: + print(newname + \ + ': warning: cannot mkdir:', msg) + ok = 0 + if ok: + linkname = os.path.join(os.pardir, + linkname) + linknames(oldname, newname, linkname) + else: + os.symlink(linkname, newname) + +if __name__ == '__main__': + sys.exit(main()) diff --git a/marketing/Tools/scripts/lll.py b/marketing/Tools/scripts/lll.py new file mode 100644 index 0000000000000000000000000000000000000000..1b48eac8aad879a360134b32ea11b4ac65854789 --- /dev/null +++ b/marketing/Tools/scripts/lll.py @@ -0,0 +1,27 @@ +#! /usr/bin/env python3 + +# Find symbolic links and show where they point to. +# Arguments are directories to search; default is current directory. +# No recursion. +# (This is a totally different program from "findsymlinks.py"!) + +import sys, os + +def lll(dirname): + for name in os.listdir(dirname): + if name not in (os.curdir, os.pardir): + full = os.path.join(dirname, name) + if os.path.islink(full): + print(name, '->', os.readlink(full)) +def main(args): + if not args: args = [os.curdir] + first = 1 + for arg in args: + if len(args) > 1: + if not first: print() + first = 0 + print(arg + ':') + lll(arg) + +if __name__ == '__main__': + main(sys.argv[1:]) diff --git a/marketing/Tools/scripts/mailerdaemon.py b/marketing/Tools/scripts/mailerdaemon.py new file mode 100644 index 0000000000000000000000000000000000000000..635e5482e63c108c55a9c2c3fc072dc95d4df91b --- /dev/null +++ b/marketing/Tools/scripts/mailerdaemon.py @@ -0,0 +1,246 @@ +#!/usr/bin/env python3 +"""Classes to parse mailer-daemon messages.""" + +import calendar +import email.message +import re +import os +import sys + + +class Unparseable(Exception): + pass + + +class ErrorMessage(email.message.Message): + def __init__(self): + email.message.Message.__init__(self) + self.sub = '' + + def is_warning(self): + sub = self.get('Subject') + if not sub: + return 0 + sub = sub.lower() + if sub.startswith('waiting mail'): + return 1 + if 'warning' in sub: + return 1 + self.sub = sub + return 0 + + def get_errors(self): + for p in EMPARSERS: + self.rewindbody() + try: + return p(self.fp, self.sub) + except Unparseable: + pass + raise Unparseable + +# List of re's or tuples of re's. +# If a re, it should contain at least a group (?P...) which +# should refer to the email address. The re can also contain a group +# (?P...) which should refer to the reason (error message). +# If no reason is present, the emparse_list_reason list is used to +# find a reason. +# If a tuple, the tuple should contain 2 re's. The first re finds a +# location, the second re is repeated one or more times to find +# multiple email addresses. The second re is matched (not searched) +# where the previous match ended. +# The re's are compiled using the re module. +emparse_list_list = [ + 'error: (?Punresolvable): (?P.+)', + ('----- The following addresses had permanent fatal errors -----\n', + '(?P[^ \n].*)\n( .*\n)?'), + 'remote execution.*\n.*rmail (?P.+)', + ('The following recipients did not receive your message:\n\n', + ' +(?P.*)\n(The following recipients did not receive your message:\n\n)?'), + '------- Failure Reasons --------\n\n(?P.*)\n(?P.*)', + '^<(?P.*)>:\n(?P.*)', + '^(?PUser mailbox exceeds allowed size): (?P.+)', + '^5\\d{2} <(?P[^\n>]+)>\\.\\.\\. (?P.+)', + '^Original-Recipient: rfc822;(?P.*)', + '^did not reach the following recipient\\(s\\):\n\n(?P.*) on .*\n +(?P.*)', + '^ <(?P[^\n>]+)> \\.\\.\\. (?P.*)', + '^Report on your message to: (?P.*)\nReason: (?P.*)', + '^Your message was not delivered to +(?P.*)\n +for the following reason:\n +(?P.*)', + '^ was not +(?P[^ \n].*?) *\n.*\n.*\n.*\n because:.*\n +(?P[^ \n].*?) *\n', + ] +# compile the re's in the list and store them in-place. +for i in range(len(emparse_list_list)): + x = emparse_list_list[i] + if type(x) is type(''): + x = re.compile(x, re.MULTILINE) + else: + xl = [] + for x in x: + xl.append(re.compile(x, re.MULTILINE)) + x = tuple(xl) + del xl + emparse_list_list[i] = x + del x +del i + +# list of re's used to find reasons (error messages). +# if a string, "<>" is replaced by a copy of the email address. +# The expressions are searched for in order. After the first match, +# no more expressions are searched for. So, order is important. +emparse_list_reason = [ + r'^5\d{2} <>\.\.\. (?P.*)', + r'<>\.\.\. (?P.*)', + re.compile(r'^<<< 5\d{2} (?P.*)', re.MULTILINE), + re.compile('===== stderr was =====\nrmail: (?P.*)'), + re.compile('^Diagnostic-Code: (?P.*)', re.MULTILINE), + ] +emparse_list_from = re.compile('^From:', re.IGNORECASE|re.MULTILINE) +def emparse_list(fp, sub): + data = fp.read() + res = emparse_list_from.search(data) + if res is None: + from_index = len(data) + else: + from_index = res.start(0) + errors = [] + emails = [] + reason = None + for regexp in emparse_list_list: + if type(regexp) is type(()): + res = regexp[0].search(data, 0, from_index) + if res is not None: + try: + reason = res.group('reason') + except IndexError: + pass + while 1: + res = regexp[1].match(data, res.end(0), from_index) + if res is None: + break + emails.append(res.group('email')) + break + else: + res = regexp.search(data, 0, from_index) + if res is not None: + emails.append(res.group('email')) + try: + reason = res.group('reason') + except IndexError: + pass + break + if not emails: + raise Unparseable + if not reason: + reason = sub + if reason[:15] == 'returned mail: ': + reason = reason[15:] + for regexp in emparse_list_reason: + if type(regexp) is type(''): + for i in range(len(emails)-1,-1,-1): + email = emails[i] + exp = re.compile(re.escape(email).join(regexp.split('<>')), re.MULTILINE) + res = exp.search(data) + if res is not None: + errors.append(' '.join((email.strip()+': '+res.group('reason')).split())) + del emails[i] + continue + res = regexp.search(data) + if res is not None: + reason = res.group('reason') + break + for email in emails: + errors.append(' '.join((email.strip()+': '+reason).split())) + return errors + +EMPARSERS = [emparse_list] + +def sort_numeric(a, b): + a = int(a) + b = int(b) + if a < b: + return -1 + elif a > b: + return 1 + else: + return 0 + +def parsedir(dir, modify): + os.chdir(dir) + pat = re.compile('^[0-9]*$') + errordict = {} + errorfirst = {} + errorlast = {} + nok = nwarn = nbad = 0 + + # find all numeric file names and sort them + files = list(filter(lambda fn, pat=pat: pat.match(fn) is not None, os.listdir('.'))) + files.sort(sort_numeric) + + for fn in files: + # Lets try to parse the file. + fp = open(fn) + m = email.message_from_file(fp, _class=ErrorMessage) + sender = m.getaddr('From') + print('%s\t%-40s\t'%(fn, sender[1]), end=' ') + + if m.is_warning(): + fp.close() + print('warning only') + nwarn = nwarn + 1 + if modify: + os.rename(fn, ','+fn) +## os.unlink(fn) + continue + + try: + errors = m.get_errors() + except Unparseable: + print('** Not parseable') + nbad = nbad + 1 + fp.close() + continue + print(len(errors), 'errors') + + # Remember them + for e in errors: + try: + mm, dd = m.getdate('date')[1:1+2] + date = '%s %02d' % (calendar.month_abbr[mm], dd) + except: + date = '??????' + if e not in errordict: + errordict[e] = 1 + errorfirst[e] = '%s (%s)' % (fn, date) + else: + errordict[e] = errordict[e] + 1 + errorlast[e] = '%s (%s)' % (fn, date) + + fp.close() + nok = nok + 1 + if modify: + os.rename(fn, ','+fn) +## os.unlink(fn) + + print('--------------') + print(nok, 'files parsed,',nwarn,'files warning-only,', end=' ') + print(nbad,'files unparseable') + print('--------------') + list = [] + for e in errordict.keys(): + list.append((errordict[e], errorfirst[e], errorlast[e], e)) + list.sort() + for num, first, last, e in list: + print('%d %s - %s\t%s' % (num, first, last, e)) + +def main(): + modify = 0 + if len(sys.argv) > 1 and sys.argv[1] == '-d': + modify = 1 + del sys.argv[1] + if len(sys.argv) > 1: + for folder in sys.argv[1:]: + parsedir(folder, modify) + else: + parsedir('/ufs/jack/Mail/errorsinbox', modify) + +if __name__ == '__main__' or sys.argv[0] == __name__: + main() diff --git a/marketing/Tools/scripts/make_ctype.py b/marketing/Tools/scripts/make_ctype.py new file mode 100644 index 0000000000000000000000000000000000000000..afee1c583330a50212ae89bae338bf50e21ab3af --- /dev/null +++ b/marketing/Tools/scripts/make_ctype.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python3 +"""Script that generates the ctype.h-replacement in stringobject.c.""" + +NAMES = ("LOWER", "UPPER", "ALPHA", "DIGIT", "XDIGIT", "ALNUM", "SPACE") + +print(""" +#define FLAG_LOWER 0x01 +#define FLAG_UPPER 0x02 +#define FLAG_ALPHA (FLAG_LOWER|FLAG_UPPER) +#define FLAG_DIGIT 0x04 +#define FLAG_ALNUM (FLAG_ALPHA|FLAG_DIGIT) +#define FLAG_SPACE 0x08 +#define FLAG_XDIGIT 0x10 + +static unsigned int ctype_table[256] = {""") + +for i in range(128): + c = chr(i) + flags = [] + for name in NAMES: + if name in ("ALPHA", "ALNUM"): + continue + if name == "XDIGIT": + method = lambda: c.isdigit() or c.upper() in "ABCDEF" + else: + method = getattr(c, "is" + name.lower()) + if method(): + flags.append("FLAG_" + name) + rc = repr(c) + if c == '\v': + rc = "'\\v'" + elif c == '\f': + rc = "'\\f'" + if not flags: + print(" 0, /* 0x%x %s */" % (i, rc)) + else: + print(" %s, /* 0x%x %s */" % ("|".join(flags), i, rc)) + +for i in range(128, 256, 16): + print(" %s," % ", ".join(16*["0"])) + +print("};") +print("") + +for name in NAMES: + print("#define IS%s(c) (ctype_table[Py_CHARMASK(c)] & FLAG_%s)" % + (name, name)) + +print("") + +for name in NAMES: + name = "is" + name.lower() + print("#undef %s" % name) + print("#define %s(c) undefined_%s(c)" % (name, name)) + +print(""" +static unsigned char ctype_tolower[256] = {""") + +for i in range(0, 256, 8): + values = [] + for i in range(i, i+8): + if i < 128: + c = chr(i) + if c.isupper(): + i = ord(c.lower()) + values.append("0x%02x" % i) + print(" %s," % ", ".join(values)) + +print("};") + +print(""" +static unsigned char ctype_toupper[256] = {""") + +for i in range(0, 256, 8): + values = [] + for i in range(i, i+8): + if i < 128: + c = chr(i) + if c.islower(): + i = ord(c.upper()) + values.append("0x%02x" % i) + print(" %s," % ", ".join(values)) + +print("};") + +print(""" +#define TOLOWER(c) (ctype_tolower[Py_CHARMASK(c)]) +#define TOUPPER(c) (ctype_toupper[Py_CHARMASK(c)]) + +#undef tolower +#define tolower(c) undefined_tolower(c) +#undef toupper +#define toupper(c) undefined_toupper(c) +""") diff --git a/marketing/Tools/scripts/md5sum.py b/marketing/Tools/scripts/md5sum.py new file mode 100644 index 0000000000000000000000000000000000000000..f910576377aa3d01b7b31ea6b21452c182a26a06 --- /dev/null +++ b/marketing/Tools/scripts/md5sum.py @@ -0,0 +1,93 @@ +#! /usr/bin/env python3 + +"""Python utility to print MD5 checksums of argument files. +""" + + +bufsize = 8096 +fnfilter = None +rmode = 'rb' + +usage = """ +usage: md5sum.py [-b] [-t] [-l] [-s bufsize] [file ...] +-b : read files in binary mode (default) +-t : read files in text mode (you almost certainly don't want this!) +-l : print last pathname component only +-s bufsize: read buffer size (default %d) +file ... : files to sum; '-' or no files means stdin +""" % bufsize + +import io +import sys +import os +import getopt +from hashlib import md5 + +def sum(*files): + sts = 0 + if files and isinstance(files[-1], io.IOBase): + out, files = files[-1], files[:-1] + else: + out = sys.stdout + if len(files) == 1 and not isinstance(files[0], str): + files = files[0] + for f in files: + if isinstance(f, str): + if f == '-': + sts = printsumfp(sys.stdin, '', out) or sts + else: + sts = printsum(f, out) or sts + else: + sts = sum(f, out) or sts + return sts + +def printsum(filename, out=sys.stdout): + try: + fp = open(filename, rmode) + except IOError as msg: + sys.stderr.write('%s: Can\'t open: %s\n' % (filename, msg)) + return 1 + with fp: + if fnfilter: + filename = fnfilter(filename) + sts = printsumfp(fp, filename, out) + return sts + +def printsumfp(fp, filename, out=sys.stdout): + m = md5() + try: + while 1: + data = fp.read(bufsize) + if not data: + break + if isinstance(data, str): + data = data.encode(fp.encoding) + m.update(data) + except IOError as msg: + sys.stderr.write('%s: I/O error: %s\n' % (filename, msg)) + return 1 + out.write('%s %s\n' % (m.hexdigest(), filename)) + return 0 + +def main(args = sys.argv[1:], out=sys.stdout): + global fnfilter, rmode, bufsize + try: + opts, args = getopt.getopt(args, 'blts:') + except getopt.error as msg: + sys.stderr.write('%s: %s\n%s' % (sys.argv[0], msg, usage)) + return 2 + for o, a in opts: + if o == '-l': + fnfilter = os.path.basename + elif o == '-b': + rmode = 'rb' + elif o == '-t': + rmode = 'r' + elif o == '-s': + bufsize = int(a) + if not args: + args = ['-'] + return sum(args, out) + +if __name__ == '__main__' or __name__ == sys.argv[0]: + sys.exit(main(sys.argv[1:], sys.stdout)) diff --git a/marketing/Tools/scripts/mkreal.py b/marketing/Tools/scripts/mkreal.py new file mode 100644 index 0000000000000000000000000000000000000000..f169da43fe116c04e1824f71985d2ecabddbef52 --- /dev/null +++ b/marketing/Tools/scripts/mkreal.py @@ -0,0 +1,65 @@ +#! /usr/bin/env python3 + +# mkreal +# +# turn a symlink to a directory into a real directory + +import sys +import os +from stat import * + +join = os.path.join + +error = 'mkreal error' + +BUFSIZE = 32*1024 + +def mkrealfile(name): + st = os.stat(name) # Get the mode + mode = S_IMODE(st[ST_MODE]) + linkto = os.readlink(name) # Make sure again it's a symlink + with open(name, 'rb') as f_in: # This ensures it's a file + os.unlink(name) + with open(name, 'wb') as f_out: + while 1: + buf = f_in.read(BUFSIZE) + if not buf: break + f_out.write(buf) + os.chmod(name, mode) + +def mkrealdir(name): + st = os.stat(name) # Get the mode + mode = S_IMODE(st[ST_MODE]) + linkto = os.readlink(name) + files = os.listdir(name) + os.unlink(name) + os.mkdir(name, mode) + os.chmod(name, mode) + linkto = join(os.pardir, linkto) + # + for filename in files: + if filename not in (os.curdir, os.pardir): + os.symlink(join(linkto, filename), join(name, filename)) + +def main(): + sys.stdout = sys.stderr + progname = os.path.basename(sys.argv[0]) + if progname == '-c': progname = 'mkreal' + args = sys.argv[1:] + if not args: + print('usage:', progname, 'path ...') + sys.exit(2) + status = 0 + for name in args: + if not os.path.islink(name): + print(progname+':', name+':', 'not a symlink') + status = 1 + else: + if os.path.isdir(name): + mkrealdir(name) + else: + mkrealfile(name) + sys.exit(status) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/ndiff.py b/marketing/Tools/scripts/ndiff.py new file mode 100644 index 0000000000000000000000000000000000000000..c6d09b8f242fef1a38e719e31927d7e136110ba0 --- /dev/null +++ b/marketing/Tools/scripts/ndiff.py @@ -0,0 +1,133 @@ +#! /usr/bin/env python3 + +# Module ndiff version 1.7.0 +# Released to the public domain 08-Dec-2000, +# by Tim Peters (tim.one@home.com). + +# Provided as-is; use at your own risk; no warranty; no promises; enjoy! + +# ndiff.py is now simply a front-end to the difflib.ndiff() function. +# Originally, it contained the difflib.SequenceMatcher class as well. +# This completes the raiding of reusable code from this formerly +# self-contained script. + +"""ndiff [-q] file1 file2 + or +ndiff (-r1 | -r2) < ndiff_output > file1_or_file2 + +Print a human-friendly file difference report to stdout. Both inter- +and intra-line differences are noted. In the second form, recreate file1 +(-r1) or file2 (-r2) on stdout, from an ndiff report on stdin. + +In the first form, if -q ("quiet") is not specified, the first two lines +of output are + +-: file1 ++: file2 + +Each remaining line begins with a two-letter code: + + "- " line unique to file1 + "+ " line unique to file2 + " " line common to both files + "? " line not present in either input file + +Lines beginning with "? " attempt to guide the eye to intraline +differences, and were not present in either input file. These lines can be +confusing if the source files contain tab characters. + +The first file can be recovered by retaining only lines that begin with +" " or "- ", and deleting those 2-character prefixes; use ndiff with -r1. + +The second file can be recovered similarly, but by retaining only " " and +"+ " lines; use ndiff with -r2; or, on Unix, the second file can be +recovered by piping the output through + + sed -n '/^[+ ] /s/^..//p' +""" + +__version__ = 1, 7, 0 + +import difflib, sys + +def fail(msg): + out = sys.stderr.write + out(msg + "\n\n") + out(__doc__) + return 0 + +# open a file & return the file object; gripe and return 0 if it +# couldn't be opened +def fopen(fname): + try: + return open(fname) + except IOError as detail: + return fail("couldn't open " + fname + ": " + str(detail)) + +# open two files & spray the diff to stdout; return false iff a problem +def fcompare(f1name, f2name): + f1 = fopen(f1name) + f2 = fopen(f2name) + if not f1 or not f2: + return 0 + + a = f1.readlines(); f1.close() + b = f2.readlines(); f2.close() + for line in difflib.ndiff(a, b): + print(line, end=' ') + + return 1 + +# crack args (sys.argv[1:] is normal) & compare; +# return false iff a problem + +def main(args): + import getopt + try: + opts, args = getopt.getopt(args, "qr:") + except getopt.error as detail: + return fail(str(detail)) + noisy = 1 + qseen = rseen = 0 + for opt, val in opts: + if opt == "-q": + qseen = 1 + noisy = 0 + elif opt == "-r": + rseen = 1 + whichfile = val + if qseen and rseen: + return fail("can't specify both -q and -r") + if rseen: + if args: + return fail("no args allowed with -r option") + if whichfile in ("1", "2"): + restore(whichfile) + return 1 + return fail("-r value must be 1 or 2") + if len(args) != 2: + return fail("need 2 filename args") + f1name, f2name = args + if noisy: + print('-:', f1name) + print('+:', f2name) + return fcompare(f1name, f2name) + +# read ndiff output from stdin, and print file1 (which=='1') or +# file2 (which=='2') to stdout + +def restore(which): + restored = difflib.restore(sys.stdin.readlines(), which) + sys.stdout.writelines(restored) + +if __name__ == '__main__': + args = sys.argv[1:] + if "-profile" in args: + import profile, pstats + args.remove("-profile") + statf = "ndiff.pro" + profile.run("main(args)", statf) + stats = pstats.Stats(statf) + stats.strip_dirs().sort_stats('time').print_stats() + else: + main(args) diff --git a/marketing/Tools/scripts/nm2def.py b/marketing/Tools/scripts/nm2def.py new file mode 100644 index 0000000000000000000000000000000000000000..a885ebd6fecc2ff7de7fd1852bc43c11e13affb6 --- /dev/null +++ b/marketing/Tools/scripts/nm2def.py @@ -0,0 +1,104 @@ +#! /usr/bin/env python3 +"""nm2def.py + +Helpers to extract symbols from Unix libs and auto-generate +Windows definition files from them. Depends on nm(1). Tested +on Linux and Solaris only (-p option to nm is for Solaris only). + +By Marc-Andre Lemburg, Aug 1998. + +Additional notes: the output of nm is supposed to look like this: + +acceler.o: +000001fd T PyGrammar_AddAccelerators + U PyGrammar_FindDFA +00000237 T PyGrammar_RemoveAccelerators + U _IO_stderr_ + U exit + U fprintf + U free + U malloc + U printf + +grammar1.o: +00000000 T PyGrammar_FindDFA +00000034 T PyGrammar_LabelRepr + U _PyParser_TokenNames + U abort + U printf + U sprintf + +... + +Even if this isn't the default output of your nm, there is generally an +option to produce this format (since it is the original v7 Unix format). + +""" +import os, sys + +PYTHONLIB = 'libpython%d.%d.a' % sys.version_info[:2] +PC_PYTHONLIB = 'Python%d%d.dll' % sys.version_info[:2] +NM = 'nm -p -g %s' # For Linux, use "nm -g %s" + +def symbols(lib=PYTHONLIB,types=('T','C','D')): + + with os.popen(NM % lib) as pipe: + lines = pipe.readlines() + lines = [s.strip() for s in lines] + symbols = {} + for line in lines: + if len(line) == 0 or ':' in line: + continue + items = line.split() + if len(items) != 3: + continue + address, type, name = items + if type not in types: + continue + symbols[name] = address,type + return symbols + +def export_list(symbols): + + data = [] + code = [] + for name,(addr,type) in symbols.items(): + if type in ('C','D'): + data.append('\t'+name) + else: + code.append('\t'+name) + data.sort() + data.append('') + code.sort() + return ' DATA\n'.join(data)+'\n'+'\n'.join(code) + +# Definition file template +DEF_TEMPLATE = """\ +EXPORTS +%s +""" + +# Special symbols that have to be included even though they don't +# pass the filter +SPECIALS = ( + ) + +def filter_Python(symbols,specials=SPECIALS): + + for name in list(symbols.keys()): + if name[:2] == 'Py' or name[:3] == '_Py': + pass + elif name not in specials: + del symbols[name] + +def main(): + + s = symbols(PYTHONLIB) + filter_Python(s) + exports = export_list(s) + f = sys.stdout # open('PC/python_nt.def','w') + f.write(DEF_TEMPLATE % (exports)) + # f.close() + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/objgraph.py b/marketing/Tools/scripts/objgraph.py new file mode 100644 index 0000000000000000000000000000000000000000..add41e692c033830ae2da2098cde2a1cb97775af --- /dev/null +++ b/marketing/Tools/scripts/objgraph.py @@ -0,0 +1,211 @@ +#! /usr/bin/env python3 + +# objgraph +# +# Read "nm -o" input of a set of libraries or modules and print various +# interesting listings, such as: +# +# - which names are used but not defined in the set (and used where), +# - which names are defined in the set (and where), +# - which modules use which other modules, +# - which modules are used by which other modules. +# +# Usage: objgraph [-cdu] [file] ... +# -c: print callers per objectfile +# -d: print callees per objectfile +# -u: print usage of undefined symbols +# If none of -cdu is specified, all are assumed. +# Use "nm -o" to generate the input +# e.g.: nm -o /lib/libc.a | objgraph + + +import sys +import os +import getopt +import re + +# Types of symbols. +# +definitions = 'TRGDSBAEC' +externals = 'UV' +ignore = 'Nntrgdsbavuc' + +# Regular expression to parse "nm -o" output. +# +matcher = re.compile('(.*):\t?........ (.) (.*)$') + +# Store "item" in "dict" under "key". +# The dictionary maps keys to lists of items. +# If there is no list for the key yet, it is created. +# +def store(dict, key, item): + if key in dict: + dict[key].append(item) + else: + dict[key] = [item] + +# Return a flattened version of a list of strings: the concatenation +# of its elements with intervening spaces. +# +def flat(list): + s = '' + for item in list: + s = s + ' ' + item + return s[1:] + +# Global variables mapping defined/undefined names to files and back. +# +file2undef = {} +def2file = {} +file2def = {} +undef2file = {} + +# Read one input file and merge the data into the tables. +# Argument is an open file. +# +def readinput(fp): + while 1: + s = fp.readline() + if not s: + break + # If you get any output from this line, + # it is probably caused by an unexpected input line: + if matcher.search(s) < 0: s; continue # Shouldn't happen + (ra, rb), (r1a, r1b), (r2a, r2b), (r3a, r3b) = matcher.regs[:4] + fn, name, type = s[r1a:r1b], s[r3a:r3b], s[r2a:r2b] + if type in definitions: + store(def2file, name, fn) + store(file2def, fn, name) + elif type in externals: + store(file2undef, fn, name) + store(undef2file, name, fn) + elif not type in ignore: + print(fn + ':' + name + ': unknown type ' + type) + +# Print all names that were undefined in some module and where they are +# defined. +# +def printcallee(): + flist = sorted(file2undef.keys()) + for filename in flist: + print(filename + ':') + elist = file2undef[filename] + elist.sort() + for ext in elist: + if len(ext) >= 8: + tabs = '\t' + else: + tabs = '\t\t' + if ext not in def2file: + print('\t' + ext + tabs + ' *undefined') + else: + print('\t' + ext + tabs + flat(def2file[ext])) + +# Print for each module the names of the other modules that use it. +# +def printcaller(): + files = sorted(file2def.keys()) + for filename in files: + callers = [] + for label in file2def[filename]: + if label in undef2file: + callers = callers + undef2file[label] + if callers: + callers.sort() + print(filename + ':') + lastfn = '' + for fn in callers: + if fn != lastfn: + print('\t' + fn) + lastfn = fn + else: + print(filename + ': unused') + +# Print undefined names and where they are used. +# +def printundef(): + undefs = {} + for filename in list(file2undef.keys()): + for ext in file2undef[filename]: + if ext not in def2file: + store(undefs, ext, filename) + elist = sorted(undefs.keys()) + for ext in elist: + print(ext + ':') + flist = sorted(undefs[ext]) + for filename in flist: + print('\t' + filename) + +# Print warning messages about names defined in more than one file. +# +def warndups(): + savestdout = sys.stdout + sys.stdout = sys.stderr + names = sorted(def2file.keys()) + for name in names: + if len(def2file[name]) > 1: + print('warning:', name, 'multiply defined:', end=' ') + print(flat(def2file[name])) + sys.stdout = savestdout + +# Main program +# +def main(): + try: + optlist, args = getopt.getopt(sys.argv[1:], 'cdu') + except getopt.error: + sys.stdout = sys.stderr + print('Usage:', os.path.basename(sys.argv[0]), end=' ') + print('[-cdu] [file] ...') + print('-c: print callers per objectfile') + print('-d: print callees per objectfile') + print('-u: print usage of undefined symbols') + print('If none of -cdu is specified, all are assumed.') + print('Use "nm -o" to generate the input') + print('e.g.: nm -o /lib/libc.a | objgraph') + return 1 + optu = optc = optd = 0 + for opt, void in optlist: + if opt == '-u': + optu = 1 + elif opt == '-c': + optc = 1 + elif opt == '-d': + optd = 1 + if optu == optc == optd == 0: + optu = optc = optd = 1 + if not args: + args = ['-'] + for filename in args: + if filename == '-': + readinput(sys.stdin) + else: + with open(filename) as f: + readinput(f) + # + warndups() + # + more = (optu + optc + optd > 1) + if optd: + if more: + print('---------------All callees------------------') + printcallee() + if optu: + if more: + print('---------------Undefined callees------------') + printundef() + if optc: + if more: + print('---------------All Callers------------------') + printcaller() + return 0 + +# Call the main program. +# Use its return value as exit status. +# Catch interrupts to avoid stack trace. +# +if __name__ == '__main__': + try: + sys.exit(main()) + except KeyboardInterrupt: + sys.exit(1) diff --git a/marketing/Tools/scripts/parse_html5_entities.py b/marketing/Tools/scripts/parse_html5_entities.py new file mode 100644 index 0000000000000000000000000000000000000000..c011328b0101bf4267d874de009690c97d77ec09 --- /dev/null +++ b/marketing/Tools/scripts/parse_html5_entities.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python3 +""" +Utility for parsing HTML5 entity definitions available from: + + http://dev.w3.org/html5/spec/entities.json + +Written by Ezio Melotti and Iuliia Proskurnia. + +""" + +import os +import sys +import json +from urllib.request import urlopen +from html.entities import html5 + +entities_url = 'http://dev.w3.org/html5/spec/entities.json' + +def get_json(url): + """Download the json file from the url and returns a decoded object.""" + with urlopen(url) as f: + data = f.read().decode('utf-8') + return json.loads(data) + +def create_dict(entities): + """Create the html5 dict from the decoded json object.""" + new_html5 = {} + for name, value in entities.items(): + new_html5[name.lstrip('&')] = value['characters'] + return new_html5 + +def compare_dicts(old, new): + """Compare the old and new dicts and print the differences.""" + added = new.keys() - old.keys() + if added: + print('{} entitie(s) have been added:'.format(len(added))) + for name in sorted(added): + print(' {!r}: {!r}'.format(name, new[name])) + removed = old.keys() - new.keys() + if removed: + print('{} entitie(s) have been removed:'.format(len(removed))) + for name in sorted(removed): + print(' {!r}: {!r}'.format(name, old[name])) + changed = set() + for name in (old.keys() & new.keys()): + if old[name] != new[name]: + changed.add((name, old[name], new[name])) + if changed: + print('{} entitie(s) have been modified:'.format(len(changed))) + for item in sorted(changed): + print(' {!r}: {!r} -> {!r}'.format(*item)) + +def write_items(entities, file=sys.stdout): + """Write the items of the dictionary in the specified file.""" + # The keys in the generated dictionary should be sorted + # in a case-insensitive way, however, when two keys are equal, + # the uppercase version should come first so that the result + # looks like: ['Aacute', 'aacute', 'Aacute;', 'aacute;', ...] + # To do this we first sort in a case-sensitive way (so all the + # uppercase chars come first) and then sort with key=str.lower. + # Since the sorting is stable the uppercase keys will eventually + # be before their equivalent lowercase version. + keys = sorted(entities.keys()) + keys = sorted(keys, key=str.lower) + print('html5 = {', file=file) + for name in keys: + print(' {!r}: {!a},'.format(name, entities[name]), file=file) + print('}', file=file) + + +if __name__ == '__main__': + # without args print a diff between html.entities.html5 and new_html5 + # with --create print the new html5 dict + # with --patch patch the Lib/html/entities.py file + new_html5 = create_dict(get_json(entities_url)) + if '--create' in sys.argv: + print('# map the HTML5 named character references to the ' + 'equivalent Unicode character(s)') + print('# Generated by {}. Do not edit manually.'.format(__file__)) + write_items(new_html5) + elif '--patch' in sys.argv: + fname = 'Lib/html/entities.py' + temp_fname = fname + '.temp' + with open(fname) as f1, open(temp_fname, 'w') as f2: + skip = False + for line in f1: + if line.startswith('html5 = {'): + write_items(new_html5, file=f2) + skip = True + continue + if skip: + # skip the old items until the } + if line.startswith('}'): + skip = False + continue + f2.write(line) + os.remove(fname) + os.rename(temp_fname, fname) + else: + if html5 == new_html5: + print('The current dictionary is updated.') + else: + compare_dicts(html5, new_html5) + print('Run "./python {0} --patch" to update Lib/html/entities.html ' + 'or "./python {0} --create" to see the generated ' 'dictionary.'.format(__file__)) diff --git a/marketing/Tools/scripts/parseentities.py b/marketing/Tools/scripts/parseentities.py new file mode 100644 index 0000000000000000000000000000000000000000..0229d3af86ba78bd4ba5b28b88cd8311ad7563bb --- /dev/null +++ b/marketing/Tools/scripts/parseentities.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +""" Utility for parsing HTML entity definitions available from: + + http://www.w3.org/ as e.g. + http://www.w3.org/TR/REC-html40/HTMLlat1.ent + + Input is read from stdin, output is written to stdout in form of a + Python snippet defining a dictionary "entitydefs" mapping literal + entity name to character or numeric entity. + + Marc-Andre Lemburg, mal@lemburg.com, 1999. + Use as you like. NO WARRANTIES. + +""" +import re,sys + +entityRE = re.compile(r'') + +def parse(text,pos=0,endpos=None): + + pos = 0 + if endpos is None: + endpos = len(text) + d = {} + while 1: + m = entityRE.search(text,pos,endpos) + if not m: + break + name,charcode,comment = m.groups() + d[name] = charcode,comment + pos = m.end() + return d + +def writefile(f,defs): + + f.write("entitydefs = {\n") + items = sorted(defs.items()) + for name, (charcode,comment) in items: + if charcode[:2] == '&#': + code = int(charcode[2:-1]) + if code < 256: + charcode = r"'\%o'" % code + else: + charcode = repr(charcode) + else: + charcode = repr(charcode) + comment = ' '.join(comment.split()) + f.write(" '%s':\t%s, \t# %s\n" % (name,charcode,comment)) + f.write('\n}\n') + +if __name__ == '__main__': + if len(sys.argv) > 1: + with open(sys.argv[1]) as infile: + text = infile.read() + else: + text = sys.stdin.read() + + defs = parse(text) + + if len(sys.argv) > 2: + with open(sys.argv[2],'w') as outfile: + writefile(outfile, defs) + else: + writefile(sys.stdout, defs) diff --git a/marketing/Tools/scripts/patchcheck.py b/marketing/Tools/scripts/patchcheck.py new file mode 100644 index 0000000000000000000000000000000000000000..8e59c78a4c58443dbed01d7a5b642e55592afc8b --- /dev/null +++ b/marketing/Tools/scripts/patchcheck.py @@ -0,0 +1,310 @@ +#!/usr/bin/env python3 +"""Check proposed changes for common issues.""" +import re +import sys +import shutil +import os.path +import subprocess +import sysconfig + +import reindent +import untabify + + +# Excluded directories which are copies of external libraries: +# don't check their coding style +EXCLUDE_DIRS = [os.path.join('Modules', '_ctypes', 'libffi_osx'), + os.path.join('Modules', '_ctypes', 'libffi_msvc'), + os.path.join('Modules', '_decimal', 'libmpdec'), + os.path.join('Modules', 'expat'), + os.path.join('Modules', 'zlib')] +SRCDIR = sysconfig.get_config_var('srcdir') + + +def n_files_str(count): + """Return 'N file(s)' with the proper plurality on 'file'.""" + return "{} file{}".format(count, "s" if count != 1 else "") + + +def status(message, modal=False, info=None): + """Decorator to output status info to stdout.""" + def decorated_fxn(fxn): + def call_fxn(*args, **kwargs): + sys.stdout.write(message + ' ... ') + sys.stdout.flush() + result = fxn(*args, **kwargs) + if not modal and not info: + print("done") + elif info: + print(info(result)) + else: + print("yes" if result else "NO") + return result + return call_fxn + return decorated_fxn + + +def get_git_branch(): + """Get the symbolic name for the current git branch""" + cmd = "git rev-parse --abbrev-ref HEAD".split() + try: + return subprocess.check_output(cmd, + stderr=subprocess.DEVNULL, + cwd=SRCDIR, + encoding='UTF-8') + except subprocess.CalledProcessError: + return None + + +def get_git_upstream_remote(): + """Get the remote name to use for upstream branches + + Uses "upstream" if it exists, "origin" otherwise + """ + cmd = "git remote get-url upstream".split() + try: + subprocess.check_output(cmd, + stderr=subprocess.DEVNULL, + cwd=SRCDIR, + encoding='UTF-8') + except subprocess.CalledProcessError: + return "origin" + return "upstream" + + +def get_git_remote_default_branch(remote_name): + """Get the name of the default branch for the given remote + + It is typically called 'main', but may differ + """ + cmd = "git remote show {}".format(remote_name).split() + env = os.environ.copy() + env['LANG'] = 'C' + try: + remote_info = subprocess.check_output(cmd, + stderr=subprocess.DEVNULL, + cwd=SRCDIR, + encoding='UTF-8', + env=env) + except subprocess.CalledProcessError: + return None + for line in remote_info.splitlines(): + if "HEAD branch:" in line: + base_branch = line.split(":")[1].strip() + return base_branch + return None + + +@status("Getting base branch for PR", + info=lambda x: x if x is not None else "not a PR branch") +def get_base_branch(): + if not os.path.exists(os.path.join(SRCDIR, '.git')): + # Not a git checkout, so there's no base branch + return None + upstream_remote = get_git_upstream_remote() + version = sys.version_info + if version.releaselevel == 'alpha': + base_branch = get_git_remote_default_branch(upstream_remote) + else: + base_branch = "{0.major}.{0.minor}".format(version) + this_branch = get_git_branch() + if this_branch is None or this_branch == base_branch: + # Not on a git PR branch, so there's no base branch + return None + return upstream_remote + "/" + base_branch + + +@status("Getting the list of files that have been added/changed", + info=lambda x: n_files_str(len(x))) +def changed_files(base_branch=None): + """Get the list of changed or added files from git.""" + if os.path.exists(os.path.join(SRCDIR, '.git')): + # We just use an existence check here as: + # directory = normal git checkout/clone + # file = git worktree directory + if base_branch: + cmd = 'git diff --name-status ' + base_branch + else: + cmd = 'git status --porcelain' + filenames = [] + with subprocess.Popen(cmd.split(), + stdout=subprocess.PIPE, + cwd=SRCDIR) as st: + for line in st.stdout: + line = line.decode().rstrip() + status_text, filename = line.split(maxsplit=1) + status = set(status_text) + # modified, added or unmerged files + if not status.intersection('MAU'): + continue + if ' -> ' in filename: + # file is renamed + filename = filename.split(' -> ', 2)[1].strip() + filenames.append(filename) + else: + sys.exit('need a git checkout to get modified files') + + filenames2 = [] + for filename in filenames: + # Normalize the path to be able to match using .startswith() + filename = os.path.normpath(filename) + if any(filename.startswith(path) for path in EXCLUDE_DIRS): + # Exclude the file + continue + filenames2.append(filename) + + return filenames2 + + +def report_modified_files(file_paths): + count = len(file_paths) + if count == 0: + return n_files_str(count) + else: + lines = ["{}:".format(n_files_str(count))] + for path in file_paths: + lines.append(" {}".format(path)) + return "\n".join(lines) + + +@status("Fixing Python file whitespace", info=report_modified_files) +def normalize_whitespace(file_paths): + """Make sure that the whitespace for .py files have been normalized.""" + reindent.makebackup = False # No need to create backups. + fixed = [path for path in file_paths if path.endswith('.py') and + reindent.check(os.path.join(SRCDIR, path))] + return fixed + + +@status("Fixing C file whitespace", info=report_modified_files) +def normalize_c_whitespace(file_paths): + """Report if any C files """ + fixed = [] + for path in file_paths: + abspath = os.path.join(SRCDIR, path) + with open(abspath, 'r') as f: + if '\t' not in f.read(): + continue + untabify.process(abspath, 8, verbose=False) + fixed.append(path) + return fixed + + +ws_re = re.compile(br'\s+(\r?\n)$') + +@status("Fixing docs whitespace", info=report_modified_files) +def normalize_docs_whitespace(file_paths): + fixed = [] + for path in file_paths: + abspath = os.path.join(SRCDIR, path) + try: + with open(abspath, 'rb') as f: + lines = f.readlines() + new_lines = [ws_re.sub(br'\1', line) for line in lines] + if new_lines != lines: + shutil.copyfile(abspath, abspath + '.bak') + with open(abspath, 'wb') as f: + f.writelines(new_lines) + fixed.append(path) + except Exception as err: + print('Cannot fix %s: %s' % (path, err)) + return fixed + + +@status("Docs modified", modal=True) +def docs_modified(file_paths): + """Report if any file in the Doc directory has been changed.""" + return bool(file_paths) + + +@status("Misc/ACKS updated", modal=True) +def credit_given(file_paths): + """Check if Misc/ACKS has been changed.""" + return os.path.join('Misc', 'ACKS') in file_paths + + +@status("Misc/NEWS.d updated with `blurb`", modal=True) +def reported_news(file_paths): + """Check if Misc/NEWS.d has been changed.""" + return any(p.startswith(os.path.join('Misc', 'NEWS.d', 'next')) + for p in file_paths) + +@status("configure regenerated", modal=True, info=str) +def regenerated_configure(file_paths): + """Check if configure has been regenerated.""" + if 'configure.ac' in file_paths: + return "yes" if 'configure' in file_paths else "no" + else: + return "not needed" + +@status("pyconfig.h.in regenerated", modal=True, info=str) +def regenerated_pyconfig_h_in(file_paths): + """Check if pyconfig.h.in has been regenerated.""" + if 'configure.ac' in file_paths: + return "yes" if 'pyconfig.h.in' in file_paths else "no" + else: + return "not needed" + +def travis(pull_request): + if pull_request == 'false': + print('Not a pull request; skipping') + return + base_branch = get_base_branch() + file_paths = changed_files(base_branch) + python_files = [fn for fn in file_paths if fn.endswith('.py')] + c_files = [fn for fn in file_paths if fn.endswith(('.c', '.h'))] + doc_files = [fn for fn in file_paths if fn.startswith('Doc') and + fn.endswith(('.rst', '.inc'))] + fixed = [] + fixed.extend(normalize_whitespace(python_files)) + fixed.extend(normalize_c_whitespace(c_files)) + fixed.extend(normalize_docs_whitespace(doc_files)) + if not fixed: + print('No whitespace issues found') + else: + print(f'Please fix the {len(fixed)} file(s) with whitespace issues') + print('(on UNIX you can run `make patchcheck` to make the fixes)') + sys.exit(1) + +def main(): + base_branch = get_base_branch() + file_paths = changed_files(base_branch) + python_files = [fn for fn in file_paths if fn.endswith('.py')] + c_files = [fn for fn in file_paths if fn.endswith(('.c', '.h'))] + doc_files = [fn for fn in file_paths if fn.startswith('Doc') and + fn.endswith(('.rst', '.inc'))] + misc_files = {p for p in file_paths if p.startswith('Misc')} + # PEP 8 whitespace rules enforcement. + normalize_whitespace(python_files) + # C rules enforcement. + normalize_c_whitespace(c_files) + # Doc whitespace enforcement. + normalize_docs_whitespace(doc_files) + # Docs updated. + docs_modified(doc_files) + # Misc/ACKS changed. + credit_given(misc_files) + # Misc/NEWS changed. + reported_news(misc_files) + # Regenerated configure, if necessary. + regenerated_configure(file_paths) + # Regenerated pyconfig.h.in, if necessary. + regenerated_pyconfig_h_in(file_paths) + + # Test suite run and passed. + if python_files or c_files: + end = " and check for refleaks?" if c_files else "?" + print() + print("Did you run the test suite" + end) + + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--travis', + help='Perform pass/fail checks') + args = parser.parse_args() + if args.travis: + travis(args.travis) + else: + main() diff --git a/marketing/Tools/scripts/pathfix.py b/marketing/Tools/scripts/pathfix.py new file mode 100644 index 0000000000000000000000000000000000000000..d252321a21a172a9cb6a483e3ad0573298f5c52a --- /dev/null +++ b/marketing/Tools/scripts/pathfix.py @@ -0,0 +1,226 @@ +#!/usr/bin/env python3 + +# Change the #! line (shebang) occurring in Python scripts. The new interpreter +# pathname must be given with a -i option. +# +# Command line arguments are files or directories to be processed. +# Directories are searched recursively for files whose name looks +# like a python module. +# Symbolic links are always ignored (except as explicit directory +# arguments). +# The original file is kept as a back-up (with a "~" attached to its name), +# -n flag can be used to disable this. + +# Sometimes you may find shebangs with flags such as `#! /usr/bin/env python -si`. +# Normally, pathfix overwrites the entire line, including the flags. +# To change interpreter and keep flags from the original shebang line, use -k. +# If you want to keep flags and add to them one single literal flag, use option -a. + + +# Undoubtedly you can do this using find and sed or perl, but this is +# a nice example of Python code that recurses down a directory tree +# and uses regular expressions. Also note several subtleties like +# preserving the file's mode and avoiding to even write a temp file +# when no changes are needed for a file. +# +# NB: by changing only the function fixfile() you can turn this +# into a program for a different change to Python programs... + +import sys +import re +import os +from stat import * +import getopt + +err = sys.stderr.write +dbg = err +rep = sys.stdout.write + +new_interpreter = None +preserve_timestamps = False +create_backup = True +keep_flags = False +add_flags = b'' + + +def main(): + global new_interpreter + global preserve_timestamps + global create_backup + global keep_flags + global add_flags + + usage = ('usage: %s -i /interpreter -p -n -k -a file-or-directory ...\n' % + sys.argv[0]) + try: + opts, args = getopt.getopt(sys.argv[1:], 'i:a:kpn') + except getopt.error as msg: + err(str(msg) + '\n') + err(usage) + sys.exit(2) + for o, a in opts: + if o == '-i': + new_interpreter = a.encode() + if o == '-p': + preserve_timestamps = True + if o == '-n': + create_backup = False + if o == '-k': + keep_flags = True + if o == '-a': + add_flags = a.encode() + if b' ' in add_flags: + err("-a option doesn't support whitespaces") + sys.exit(2) + if not new_interpreter or not new_interpreter.startswith(b'/') or \ + not args: + err('-i option or file-or-directory missing\n') + err(usage) + sys.exit(2) + bad = 0 + for arg in args: + if os.path.isdir(arg): + if recursedown(arg): bad = 1 + elif os.path.islink(arg): + err(arg + ': will not process symbolic links\n') + bad = 1 + else: + if fix(arg): bad = 1 + sys.exit(bad) + + +def ispython(name): + return name.endswith('.py') + + +def recursedown(dirname): + dbg('recursedown(%r)\n' % (dirname,)) + bad = 0 + try: + names = os.listdir(dirname) + except OSError as msg: + err('%s: cannot list directory: %r\n' % (dirname, msg)) + return 1 + names.sort() + subdirs = [] + for name in names: + if name in (os.curdir, os.pardir): continue + fullname = os.path.join(dirname, name) + if os.path.islink(fullname): pass + elif os.path.isdir(fullname): + subdirs.append(fullname) + elif ispython(name): + if fix(fullname): bad = 1 + for fullname in subdirs: + if recursedown(fullname): bad = 1 + return bad + + +def fix(filename): +## dbg('fix(%r)\n' % (filename,)) + try: + f = open(filename, 'rb') + except IOError as msg: + err('%s: cannot open: %r\n' % (filename, msg)) + return 1 + with f: + line = f.readline() + fixed = fixline(line) + if line == fixed: + rep(filename+': no change\n') + return + head, tail = os.path.split(filename) + tempname = os.path.join(head, '@' + tail) + try: + g = open(tempname, 'wb') + except IOError as msg: + err('%s: cannot create: %r\n' % (tempname, msg)) + return 1 + with g: + rep(filename + ': updating\n') + g.write(fixed) + BUFSIZE = 8*1024 + while 1: + buf = f.read(BUFSIZE) + if not buf: break + g.write(buf) + + # Finishing touch -- move files + + mtime = None + atime = None + # First copy the file's mode to the temp file + try: + statbuf = os.stat(filename) + mtime = statbuf.st_mtime + atime = statbuf.st_atime + os.chmod(tempname, statbuf[ST_MODE] & 0o7777) + except OSError as msg: + err('%s: warning: chmod failed (%r)\n' % (tempname, msg)) + # Then make a backup of the original file as filename~ + if create_backup: + try: + os.rename(filename, filename + '~') + except OSError as msg: + err('%s: warning: backup failed (%r)\n' % (filename, msg)) + else: + try: + os.remove(filename) + except OSError as msg: + err('%s: warning: removing failed (%r)\n' % (filename, msg)) + # Now move the temp file to the original file + try: + os.rename(tempname, filename) + except OSError as msg: + err('%s: rename failed (%r)\n' % (filename, msg)) + return 1 + if preserve_timestamps: + if atime and mtime: + try: + os.utime(filename, (atime, mtime)) + except OSError as msg: + err('%s: reset of timestamp failed (%r)\n' % (filename, msg)) + return 1 + # Return success + return 0 + + +def parse_shebang(shebangline): + shebangline = shebangline.rstrip(b'\n') + start = shebangline.find(b' -') + if start == -1: + return b'' + return shebangline[start:] + + +def populate_flags(shebangline): + old_flags = b'' + if keep_flags: + old_flags = parse_shebang(shebangline) + if old_flags: + old_flags = old_flags[2:] + if not (old_flags or add_flags): + return b'' + # On Linux, the entire string following the interpreter name + # is passed as a single argument to the interpreter. + # e.g. "#! /usr/bin/python3 -W Error -s" runs "/usr/bin/python3 "-W Error -s" + # so shebang should have single '-' where flags are given and + # flag might need argument for that reasons adding new flags is + # between '-' and original flags + # e.g. #! /usr/bin/python3 -sW Error + return b' -' + add_flags + old_flags + + +def fixline(line): + if not line.startswith(b'#!'): + return line + + if b"python" not in line: + return line + + flags = populate_flags(line) + return b'#! ' + new_interpreter + flags + b'\n' + + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/pdeps.py b/marketing/Tools/scripts/pdeps.py new file mode 100644 index 0000000000000000000000000000000000000000..4e8e930948f1ff433307f5400fa2298a021ae374 --- /dev/null +++ b/marketing/Tools/scripts/pdeps.py @@ -0,0 +1,164 @@ +#! /usr/bin/env python3 + +# pdeps +# +# Find dependencies between a bunch of Python modules. +# +# Usage: +# pdeps file1.py file2.py ... +# +# Output: +# Four tables separated by lines like '--- Closure ---': +# 1) Direct dependencies, listing which module imports which other modules +# 2) The inverse of (1) +# 3) Indirect dependencies, or the closure of the above +# 4) The inverse of (3) +# +# To do: +# - command line options to select output type +# - option to automatically scan the Python library for referenced modules +# - option to limit output to particular modules + + +import sys +import re +import os + + +# Main program +# +def main(): + args = sys.argv[1:] + if not args: + print('usage: pdeps file.py file.py ...') + return 2 + # + table = {} + for arg in args: + process(arg, table) + # + print('--- Uses ---') + printresults(table) + # + print('--- Used By ---') + inv = inverse(table) + printresults(inv) + # + print('--- Closure of Uses ---') + reach = closure(table) + printresults(reach) + # + print('--- Closure of Used By ---') + invreach = inverse(reach) + printresults(invreach) + # + return 0 + + +# Compiled regular expressions to search for import statements +# +m_import = re.compile('^[ \t]*from[ \t]+([^ \t]+)[ \t]+') +m_from = re.compile('^[ \t]*import[ \t]+([^#]+)') + + +# Collect data from one file +# +def process(filename, table): + with open(filename) as fp: + mod = os.path.basename(filename) + if mod[-3:] == '.py': + mod = mod[:-3] + table[mod] = list = [] + while 1: + line = fp.readline() + if not line: break + while line[-1:] == '\\': + nextline = fp.readline() + if not nextline: break + line = line[:-1] + nextline + m_found = m_import.match(line) or m_from.match(line) + if m_found: + (a, b), (a1, b1) = m_found.regs[:2] + else: continue + words = line[a1:b1].split(',') + # print '#', line, words + for word in words: + word = word.strip() + if word not in list: + list.append(word) + + +# Compute closure (this is in fact totally general) +# +def closure(table): + modules = list(table.keys()) + # + # Initialize reach with a copy of table + # + reach = {} + for mod in modules: + reach[mod] = table[mod][:] + # + # Iterate until no more change + # + change = 1 + while change: + change = 0 + for mod in modules: + for mo in reach[mod]: + if mo in modules: + for m in reach[mo]: + if m not in reach[mod]: + reach[mod].append(m) + change = 1 + # + return reach + + +# Invert a table (this is again totally general). +# All keys of the original table are made keys of the inverse, +# so there may be empty lists in the inverse. +# +def inverse(table): + inv = {} + for key in table.keys(): + if key not in inv: + inv[key] = [] + for item in table[key]: + store(inv, item, key) + return inv + + +# Store "item" in "dict" under "key". +# The dictionary maps keys to lists of items. +# If there is no list for the key yet, it is created. +# +def store(dict, key, item): + if key in dict: + dict[key].append(item) + else: + dict[key] = [item] + + +# Tabulate results neatly +# +def printresults(table): + modules = sorted(table.keys()) + maxlen = 0 + for mod in modules: maxlen = max(maxlen, len(mod)) + for mod in modules: + list = sorted(table[mod]) + print(mod.ljust(maxlen), ':', end=' ') + if mod in list: + print('(*)', end=' ') + for ref in list: + print(ref, end=' ') + print() + + +# Call main and honor exit status +if __name__ == '__main__': + try: + sys.exit(main()) + except KeyboardInterrupt: + sys.exit(1) diff --git a/marketing/Tools/scripts/pep384_macrocheck.py b/marketing/Tools/scripts/pep384_macrocheck.py new file mode 100644 index 0000000000000000000000000000000000000000..ab9dd7c972aab5cb9d4c8c34bde4449ce4d621e4 --- /dev/null +++ b/marketing/Tools/scripts/pep384_macrocheck.py @@ -0,0 +1,148 @@ +""" +pep384_macrocheck.py + +This program tries to locate errors in the relevant Python header +files where macros access type fields when they are reachable from +the limited API. + +The idea is to search macros with the string "->tp_" in it. +When the macro name does not begin with an underscore, +then we have found a dormant error. + +Christian Tismer +2018-06-02 +""" + +import sys +import os +import re + + +DEBUG = False + +def dprint(*args, **kw): + if DEBUG: + print(*args, **kw) + +def parse_headerfiles(startpath): + """ + Scan all header files which are reachable fronm Python.h + """ + search = "Python.h" + name = os.path.join(startpath, search) + if not os.path.exists(name): + raise ValueError("file {} was not found in {}\n" + "Please give the path to Python's include directory." + .format(search, startpath)) + errors = 0 + with open(name) as python_h: + while True: + line = python_h.readline() + if not line: + break + found = re.match(r'^\s*#\s*include\s*"(\w+\.h)"', line) + if not found: + continue + include = found.group(1) + dprint("Scanning", include) + name = os.path.join(startpath, include) + if not os.path.exists(name): + name = os.path.join(startpath, "../PC", include) + errors += parse_file(name) + return errors + +def ifdef_level_gen(): + """ + Scan lines for #ifdef and track the level. + """ + level = 0 + ifdef_pattern = r"^\s*#\s*if" # covers ifdef and ifndef as well + endif_pattern = r"^\s*#\s*endif" + while True: + line = yield level + if re.match(ifdef_pattern, line): + level += 1 + elif re.match(endif_pattern, line): + level -= 1 + +def limited_gen(): + """ + Scan lines for Py_LIMITED_API yes(1) no(-1) or nothing (0) + """ + limited = [0] # nothing + unlimited_pattern = r"^\s*#\s*ifndef\s+Py_LIMITED_API" + limited_pattern = "|".join([ + r"^\s*#\s*ifdef\s+Py_LIMITED_API", + r"^\s*#\s*(el)?if\s+!\s*defined\s*\(\s*Py_LIMITED_API\s*\)\s*\|\|", + r"^\s*#\s*(el)?if\s+defined\s*\(\s*Py_LIMITED_API" + ]) + else_pattern = r"^\s*#\s*else" + ifdef_level = ifdef_level_gen() + status = next(ifdef_level) + wait_for = -1 + while True: + line = yield limited[-1] + new_status = ifdef_level.send(line) + dir = new_status - status + status = new_status + if dir == 1: + if re.match(unlimited_pattern, line): + limited.append(-1) + wait_for = status - 1 + elif re.match(limited_pattern, line): + limited.append(1) + wait_for = status - 1 + elif dir == -1: + # this must have been an endif + if status == wait_for: + limited.pop() + wait_for = -1 + else: + # it could be that we have an elif + if re.match(limited_pattern, line): + limited.append(1) + wait_for = status - 1 + elif re.match(else_pattern, line): + limited.append(-limited.pop()) # negate top + +def parse_file(fname): + errors = 0 + with open(fname) as f: + lines = f.readlines() + type_pattern = r"^.*?->\s*tp_" + define_pattern = r"^\s*#\s*define\s+(\w+)" + limited = limited_gen() + status = next(limited) + for nr, line in enumerate(lines): + status = limited.send(line) + line = line.rstrip() + dprint(fname, nr, status, line) + if status != -1: + if re.match(define_pattern, line): + name = re.match(define_pattern, line).group(1) + if not name.startswith("_"): + # found a candidate, check it! + macro = line + "\n" + idx = nr + while line.endswith("\\"): + idx += 1 + line = lines[idx].rstrip() + macro += line + "\n" + if re.match(type_pattern, macro, re.DOTALL): + # this type field can reach the limited API + report(fname, nr + 1, macro) + errors += 1 + return errors + +def report(fname, nr, macro): + f = sys.stderr + print(fname + ":" + str(nr), file=f) + print(macro, file=f) + +if __name__ == "__main__": + p = sys.argv[1] if sys.argv[1:] else "../../Include" + errors = parse_headerfiles(p) + if errors: + # somehow it makes sense to raise a TypeError :-) + raise TypeError("These {} locations contradict the limited API." + .format(errors)) diff --git a/marketing/Tools/scripts/pickle2db.py b/marketing/Tools/scripts/pickle2db.py new file mode 100644 index 0000000000000000000000000000000000000000..b5b6571863282fbbcadce0e6c23607c80e0b8ea5 --- /dev/null +++ b/marketing/Tools/scripts/pickle2db.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 + +""" +Synopsis: %(prog)s [-h|-b|-g|-r|-a|-d] [ picklefile ] dbfile + +Read the given picklefile as a series of key/value pairs and write to a new +database. If the database already exists, any contents are deleted. The +optional flags indicate the type of the output database: + + -a - open using dbm (open any supported format) + -b - open as bsddb btree file + -d - open as dbm.ndbm file + -g - open as dbm.gnu file + -h - open as bsddb hash file + -r - open as bsddb recno file + +The default is hash. If a pickle file is named it is opened for read +access. If no pickle file is named, the pickle input is read from standard +input. + +Note that recno databases can only contain integer keys, so you can't dump a +hash or btree database using db2pickle.py and reconstitute it to a recno +database with %(prog)s unless your keys are integers. + +""" + +import getopt +try: + import bsddb +except ImportError: + bsddb = None +try: + import dbm.ndbm as dbm +except ImportError: + dbm = None +try: + import dbm.gnu as gdbm +except ImportError: + gdbm = None +try: + import dbm.ndbm as anydbm +except ImportError: + anydbm = None +import sys +try: + import pickle as pickle +except ImportError: + import pickle + +prog = sys.argv[0] + +def usage(): + sys.stderr.write(__doc__ % globals()) + +def main(args): + try: + opts, args = getopt.getopt(args, "hbrdag", + ["hash", "btree", "recno", "dbm", "anydbm", + "gdbm"]) + except getopt.error: + usage() + return 1 + + if len(args) == 0 or len(args) > 2: + usage() + return 1 + elif len(args) == 1: + pfile = sys.stdin + dbfile = args[0] + else: + try: + pfile = open(args[0], 'rb') + except IOError: + sys.stderr.write("Unable to open %s\n" % args[0]) + return 1 + dbfile = args[1] + + dbopen = None + for opt, arg in opts: + if opt in ("-h", "--hash"): + try: + dbopen = bsddb.hashopen + except AttributeError: + sys.stderr.write("bsddb module unavailable.\n") + return 1 + elif opt in ("-b", "--btree"): + try: + dbopen = bsddb.btopen + except AttributeError: + sys.stderr.write("bsddb module unavailable.\n") + return 1 + elif opt in ("-r", "--recno"): + try: + dbopen = bsddb.rnopen + except AttributeError: + sys.stderr.write("bsddb module unavailable.\n") + return 1 + elif opt in ("-a", "--anydbm"): + try: + dbopen = anydbm.open + except AttributeError: + sys.stderr.write("dbm module unavailable.\n") + return 1 + elif opt in ("-g", "--gdbm"): + try: + dbopen = gdbm.open + except AttributeError: + sys.stderr.write("dbm.gnu module unavailable.\n") + return 1 + elif opt in ("-d", "--dbm"): + try: + dbopen = dbm.open + except AttributeError: + sys.stderr.write("dbm.ndbm module unavailable.\n") + return 1 + if dbopen is None: + if bsddb is None: + sys.stderr.write("bsddb module unavailable - ") + sys.stderr.write("must specify dbtype.\n") + return 1 + else: + dbopen = bsddb.hashopen + + try: + db = dbopen(dbfile, 'c') + except bsddb.error: + sys.stderr.write("Unable to open %s. " % dbfile) + sys.stderr.write("Check for format or version mismatch.\n") + return 1 + else: + for k in list(db.keys()): + del db[k] + + while 1: + try: + (key, val) = pickle.load(pfile) + except EOFError: + break + db[key] = val + + db.close() + pfile.close() + + return 0 + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/marketing/Tools/scripts/pindent.py b/marketing/Tools/scripts/pindent.py new file mode 100644 index 0000000000000000000000000000000000000000..33334204a4d455d26ae5ca36582003ab66e64c5a --- /dev/null +++ b/marketing/Tools/scripts/pindent.py @@ -0,0 +1,506 @@ +#! /usr/bin/env python3 + +# This file contains a class and a main program that perform three +# related (though complimentary) formatting operations on Python +# programs. When called as "pindent -c", it takes a valid Python +# program as input and outputs a version augmented with block-closing +# comments. When called as "pindent -d", it assumes its input is a +# Python program with block-closing comments and outputs a commentless +# version. When called as "pindent -r" it assumes its input is a +# Python program with block-closing comments but with its indentation +# messed up, and outputs a properly indented version. + +# A "block-closing comment" is a comment of the form '# end ' +# where is the keyword that opened the block. If the +# opening keyword is 'def' or 'class', the function or class name may +# be repeated in the block-closing comment as well. Here is an +# example of a program fully augmented with block-closing comments: + +# def foobar(a, b): +# if a == b: +# a = a+1 +# elif a < b: +# b = b-1 +# if b > a: a = a-1 +# # end if +# else: +# print 'oops!' +# # end if +# # end def foobar + +# Note that only the last part of an if...elif...else... block needs a +# block-closing comment; the same is true for other compound +# statements (e.g. try...except). Also note that "short-form" blocks +# like the second 'if' in the example must be closed as well; +# otherwise the 'else' in the example would be ambiguous (remember +# that indentation is not significant when interpreting block-closing +# comments). + +# The operations are idempotent (i.e. applied to their own output +# they yield an identical result). Running first "pindent -c" and +# then "pindent -r" on a valid Python program produces a program that +# is semantically identical to the input (though its indentation may +# be different). Running "pindent -e" on that output produces a +# program that only differs from the original in indentation. + +# Other options: +# -s stepsize: set the indentation step size (default 8) +# -t tabsize : set the number of spaces a tab character is worth (default 8) +# -e : expand TABs into spaces +# file ... : input file(s) (default standard input) +# The results always go to standard output + +# Caveats: +# - comments ending in a backslash will be mistaken for continued lines +# - continuations using backslash are always left unchanged +# - continuations inside parentheses are not extra indented by -r +# but must be indented for -c to work correctly (this breaks +# idempotency!) +# - continued lines inside triple-quoted strings are totally garbled + +# Secret feature: +# - On input, a block may also be closed with an "end statement" -- +# this is a block-closing comment without the '#' sign. + +# Possible improvements: +# - check syntax based on transitions in 'next' table +# - better error reporting +# - better error recovery +# - check identifier after class/def + +# The following wishes need a more complete tokenization of the source: +# - Don't get fooled by comments ending in backslash +# - reindent continuation lines indicated by backslash +# - handle continuation lines inside parentheses/braces/brackets +# - handle triple quoted strings spanning lines +# - realign comments +# - optionally do much more thorough reformatting, a la C indent + +# Defaults +STEPSIZE = 8 +TABSIZE = 8 +EXPANDTABS = False + +import io +import re +import sys + +next = {} +next['if'] = next['elif'] = 'elif', 'else', 'end' +next['while'] = next['for'] = 'else', 'end' +next['try'] = 'except', 'finally' +next['except'] = 'except', 'else', 'finally', 'end' +next['else'] = next['finally'] = next['with'] = \ + next['def'] = next['class'] = 'end' +next['end'] = () +start = 'if', 'while', 'for', 'try', 'with', 'def', 'class' + +class PythonIndenter: + + def __init__(self, fpi = sys.stdin, fpo = sys.stdout, + indentsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + self.fpi = fpi + self.fpo = fpo + self.indentsize = indentsize + self.tabsize = tabsize + self.lineno = 0 + self.expandtabs = expandtabs + self._write = fpo.write + self.kwprog = re.compile( + r'^(?:\s|\\\n)*(?P[a-z]+)' + r'((?:\s|\\\n)+(?P[a-zA-Z_]\w*))?' + r'[^\w]') + self.endprog = re.compile( + r'^(?:\s|\\\n)*#?\s*end\s+(?P[a-z]+)' + r'(\s+(?P[a-zA-Z_]\w*))?' + r'[^\w]') + self.wsprog = re.compile(r'^[ \t]*') + # end def __init__ + + def write(self, line): + if self.expandtabs: + self._write(line.expandtabs(self.tabsize)) + else: + self._write(line) + # end if + # end def write + + def readline(self): + line = self.fpi.readline() + if line: self.lineno += 1 + # end if + return line + # end def readline + + def error(self, fmt, *args): + if args: fmt = fmt % args + # end if + sys.stderr.write('Error at line %d: %s\n' % (self.lineno, fmt)) + self.write('### %s ###\n' % fmt) + # end def error + + def getline(self): + line = self.readline() + while line[-2:] == '\\\n': + line2 = self.readline() + if not line2: break + # end if + line += line2 + # end while + return line + # end def getline + + def putline(self, line, indent): + tabs, spaces = divmod(indent*self.indentsize, self.tabsize) + i = self.wsprog.match(line).end() + line = line[i:] + if line[:1] not in ('\n', '\r', ''): + line = '\t'*tabs + ' '*spaces + line + # end if + self.write(line) + # end def putline + + def reformat(self): + stack = [] + while True: + line = self.getline() + if not line: break # EOF + # end if + m = self.endprog.match(line) + if m: + kw = 'end' + kw2 = m.group('kw') + if not stack: + self.error('unexpected end') + elif stack.pop()[0] != kw2: + self.error('unmatched end') + # end if + self.putline(line, len(stack)) + continue + # end if + m = self.kwprog.match(line) + if m: + kw = m.group('kw') + if kw in start: + self.putline(line, len(stack)) + stack.append((kw, kw)) + continue + # end if + if kw in next and stack: + self.putline(line, len(stack)-1) + kwa, kwb = stack[-1] + stack[-1] = kwa, kw + continue + # end if + # end if + self.putline(line, len(stack)) + # end while + if stack: + self.error('unterminated keywords') + for kwa, kwb in stack: + self.write('\t%s\n' % kwa) + # end for + # end if + # end def reformat + + def delete(self): + begin_counter = 0 + end_counter = 0 + while True: + line = self.getline() + if not line: break # EOF + # end if + m = self.endprog.match(line) + if m: + end_counter += 1 + continue + # end if + m = self.kwprog.match(line) + if m: + kw = m.group('kw') + if kw in start: + begin_counter += 1 + # end if + # end if + self.write(line) + # end while + if begin_counter - end_counter < 0: + sys.stderr.write('Warning: input contained more end tags than expected\n') + elif begin_counter - end_counter > 0: + sys.stderr.write('Warning: input contained less end tags than expected\n') + # end if + # end def delete + + def complete(self): + stack = [] + todo = [] + currentws = thisid = firstkw = lastkw = topid = '' + while True: + line = self.getline() + i = self.wsprog.match(line).end() + m = self.endprog.match(line) + if m: + thiskw = 'end' + endkw = m.group('kw') + thisid = m.group('id') + else: + m = self.kwprog.match(line) + if m: + thiskw = m.group('kw') + if thiskw not in next: + thiskw = '' + # end if + if thiskw in ('def', 'class'): + thisid = m.group('id') + else: + thisid = '' + # end if + elif line[i:i+1] in ('\n', '#'): + todo.append(line) + continue + else: + thiskw = '' + # end if + # end if + indentws = line[:i] + indent = len(indentws.expandtabs(self.tabsize)) + current = len(currentws.expandtabs(self.tabsize)) + while indent < current: + if firstkw: + if topid: + s = '# end %s %s\n' % ( + firstkw, topid) + else: + s = '# end %s\n' % firstkw + # end if + self.write(currentws + s) + firstkw = lastkw = '' + # end if + currentws, firstkw, lastkw, topid = stack.pop() + current = len(currentws.expandtabs(self.tabsize)) + # end while + if indent == current and firstkw: + if thiskw == 'end': + if endkw != firstkw: + self.error('mismatched end') + # end if + firstkw = lastkw = '' + elif not thiskw or thiskw in start: + if topid: + s = '# end %s %s\n' % ( + firstkw, topid) + else: + s = '# end %s\n' % firstkw + # end if + self.write(currentws + s) + firstkw = lastkw = topid = '' + # end if + # end if + if indent > current: + stack.append((currentws, firstkw, lastkw, topid)) + if thiskw and thiskw not in start: + # error + thiskw = '' + # end if + currentws, firstkw, lastkw, topid = \ + indentws, thiskw, thiskw, thisid + # end if + if thiskw: + if thiskw in start: + firstkw = lastkw = thiskw + topid = thisid + else: + lastkw = thiskw + # end if + # end if + for l in todo: self.write(l) + # end for + todo = [] + if not line: break + # end if + self.write(line) + # end while + # end def complete +# end class PythonIndenter + +# Simplified user interface +# - xxx_filter(input, output): read and write file objects +# - xxx_string(s): take and return string object +# - xxx_file(filename): process file in place, return true iff changed + +def complete_filter(input = sys.stdin, output = sys.stdout, + stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs) + pi.complete() +# end def complete_filter + +def delete_filter(input= sys.stdin, output = sys.stdout, + stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs) + pi.delete() +# end def delete_filter + +def reformat_filter(input = sys.stdin, output = sys.stdout, + stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs) + pi.reformat() +# end def reformat_filter + +def complete_string(source, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + input = io.StringIO(source) + output = io.StringIO() + pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs) + pi.complete() + return output.getvalue() +# end def complete_string + +def delete_string(source, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + input = io.StringIO(source) + output = io.StringIO() + pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs) + pi.delete() + return output.getvalue() +# end def delete_string + +def reformat_string(source, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + input = io.StringIO(source) + output = io.StringIO() + pi = PythonIndenter(input, output, stepsize, tabsize, expandtabs) + pi.reformat() + return output.getvalue() +# end def reformat_string + +def make_backup(filename): + import os, os.path + backup = filename + '~' + if os.path.lexists(backup): + try: + os.remove(backup) + except OSError: + print("Can't remove backup %r" % (backup,), file=sys.stderr) + # end try + # end if + try: + os.rename(filename, backup) + except OSError: + print("Can't rename %r to %r" % (filename, backup), file=sys.stderr) + # end try +# end def make_backup + +def complete_file(filename, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + with open(filename, 'r') as f: + source = f.read() + # end with + result = complete_string(source, stepsize, tabsize, expandtabs) + if source == result: return 0 + # end if + make_backup(filename) + with open(filename, 'w') as f: + f.write(result) + # end with + return 1 +# end def complete_file + +def delete_file(filename, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + with open(filename, 'r') as f: + source = f.read() + # end with + result = delete_string(source, stepsize, tabsize, expandtabs) + if source == result: return 0 + # end if + make_backup(filename) + with open(filename, 'w') as f: + f.write(result) + # end with + return 1 +# end def delete_file + +def reformat_file(filename, stepsize = STEPSIZE, tabsize = TABSIZE, expandtabs = EXPANDTABS): + with open(filename, 'r') as f: + source = f.read() + # end with + result = reformat_string(source, stepsize, tabsize, expandtabs) + if source == result: return 0 + # end if + make_backup(filename) + with open(filename, 'w') as f: + f.write(result) + # end with + return 1 +# end def reformat_file + +# Test program when called as a script + +usage = """ +usage: pindent (-c|-d|-r) [-s stepsize] [-t tabsize] [-e] [file] ... +-c : complete a correctly indented program (add #end directives) +-d : delete #end directives +-r : reformat a completed program (use #end directives) +-s stepsize: indentation step (default %(STEPSIZE)d) +-t tabsize : the worth in spaces of a tab (default %(TABSIZE)d) +-e : expand TABs into spaces (default OFF) +[file] ... : files are changed in place, with backups in file~ +If no files are specified or a single - is given, +the program acts as a filter (reads stdin, writes stdout). +""" % vars() + +def error_both(op1, op2): + sys.stderr.write('Error: You can not specify both '+op1+' and -'+op2[0]+' at the same time\n') + sys.stderr.write(usage) + sys.exit(2) +# end def error_both + +def test(): + import getopt + try: + opts, args = getopt.getopt(sys.argv[1:], 'cdrs:t:e') + except getopt.error as msg: + sys.stderr.write('Error: %s\n' % msg) + sys.stderr.write(usage) + sys.exit(2) + # end try + action = None + stepsize = STEPSIZE + tabsize = TABSIZE + expandtabs = EXPANDTABS + for o, a in opts: + if o == '-c': + if action: error_both(o, action) + # end if + action = 'complete' + elif o == '-d': + if action: error_both(o, action) + # end if + action = 'delete' + elif o == '-r': + if action: error_both(o, action) + # end if + action = 'reformat' + elif o == '-s': + stepsize = int(a) + elif o == '-t': + tabsize = int(a) + elif o == '-e': + expandtabs = True + # end if + # end for + if not action: + sys.stderr.write( + 'You must specify -c(omplete), -d(elete) or -r(eformat)\n') + sys.stderr.write(usage) + sys.exit(2) + # end if + if not args or args == ['-']: + action = eval(action + '_filter') + action(sys.stdin, sys.stdout, stepsize, tabsize, expandtabs) + else: + action = eval(action + '_file') + for filename in args: + action(filename, stepsize, tabsize, expandtabs) + # end for + # end if +# end def test + +if __name__ == '__main__': + test() +# end if diff --git a/marketing/Tools/scripts/ptags.py b/marketing/Tools/scripts/ptags.py new file mode 100644 index 0000000000000000000000000000000000000000..eedd411702c1991849fea6ed75c8c27204c9bff0 --- /dev/null +++ b/marketing/Tools/scripts/ptags.py @@ -0,0 +1,54 @@ +#! /usr/bin/env python3 + +# ptags +# +# Create a tags file for Python programs, usable with vi. +# Tagged are: +# - functions (even inside other defs or classes) +# - classes +# - filenames +# Warns about files it cannot open. +# No warnings about duplicate tags. + +import sys, re, os + +tags = [] # Modified global variable! + +def main(): + args = sys.argv[1:] + for filename in args: + treat_file(filename) + if tags: + with open('tags', 'w') as fp: + tags.sort() + for s in tags: fp.write(s) + + +expr = r'^[ \t]*(def|class)[ \t]+([a-zA-Z0-9_]+)[ \t]*[:\(]' +matcher = re.compile(expr) + +def treat_file(filename): + try: + fp = open(filename, 'r') + except: + sys.stderr.write('Cannot open %s\n' % filename) + return + with fp: + base = os.path.basename(filename) + if base[-3:] == '.py': + base = base[:-3] + s = base + '\t' + filename + '\t' + '1\n' + tags.append(s) + while 1: + line = fp.readline() + if not line: + break + m = matcher.match(line) + if m: + content = m.group(0) + name = m.group(2) + s = name + '\t' + filename + '\t/^' + content + '/\n' + tags.append(s) + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/pydoc3.py b/marketing/Tools/scripts/pydoc3.py new file mode 100644 index 0000000000000000000000000000000000000000..c9b83bb55b208b4520b1561999dae60975f643c4 --- /dev/null +++ b/marketing/Tools/scripts/pydoc3.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python3 + +import pydoc +if __name__ == '__main__': + pydoc.cli() diff --git a/marketing/Tools/scripts/pysource.py b/marketing/Tools/scripts/pysource.py new file mode 100644 index 0000000000000000000000000000000000000000..69e8e0df4ff0802fc31bfb829fdc83bb4907b92e --- /dev/null +++ b/marketing/Tools/scripts/pysource.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 + +"""\ +List python source files. + +There are three functions to check whether a file is a Python source, listed +here with increasing complexity: + +- has_python_ext() checks whether a file name ends in '.py[w]'. +- look_like_python() checks whether the file is not binary and either has + the '.py[w]' extension or the first line contains the word 'python'. +- can_be_compiled() checks whether the file can be compiled by compile(). + +The file also must be of appropriate size - not bigger than a megabyte. + +walk_python_files() recursively lists all Python files under the given directories. +""" +__author__ = "Oleg Broytmann, Georg Brandl" + +__all__ = ["has_python_ext", "looks_like_python", "can_be_compiled", "walk_python_files"] + + +import os, re + +binary_re = re.compile(br'[\x00-\x08\x0E-\x1F\x7F]') + +debug = False + +def print_debug(msg): + if debug: print(msg) + + +def _open(fullpath): + try: + size = os.stat(fullpath).st_size + except OSError as err: # Permission denied - ignore the file + print_debug("%s: permission denied: %s" % (fullpath, err)) + return None + + if size > 1024*1024: # too big + print_debug("%s: the file is too big: %d bytes" % (fullpath, size)) + return None + + try: + return open(fullpath, "rb") + except IOError as err: # Access denied, or a special file - ignore it + print_debug("%s: access denied: %s" % (fullpath, err)) + return None + +def has_python_ext(fullpath): + return fullpath.endswith(".py") or fullpath.endswith(".pyw") + +def looks_like_python(fullpath): + infile = _open(fullpath) + if infile is None: + return False + + with infile: + line = infile.readline() + + if binary_re.search(line): + # file appears to be binary + print_debug("%s: appears to be binary" % fullpath) + return False + + if fullpath.endswith(".py") or fullpath.endswith(".pyw"): + return True + elif b"python" in line: + # disguised Python script (e.g. CGI) + return True + + return False + +def can_be_compiled(fullpath): + infile = _open(fullpath) + if infile is None: + return False + + with infile: + code = infile.read() + + try: + compile(code, fullpath, "exec") + except Exception as err: + print_debug("%s: cannot compile: %s" % (fullpath, err)) + return False + + return True + + +def walk_python_files(paths, is_python=looks_like_python, exclude_dirs=None): + """\ + Recursively yield all Python source files below the given paths. + + paths: a list of files and/or directories to be checked. + is_python: a function that takes a file name and checks whether it is a + Python source file + exclude_dirs: a list of directory base names that should be excluded in + the search + """ + if exclude_dirs is None: + exclude_dirs=[] + + for path in paths: + print_debug("testing: %s" % path) + if os.path.isfile(path): + if is_python(path): + yield path + elif os.path.isdir(path): + print_debug(" it is a directory") + for dirpath, dirnames, filenames in os.walk(path): + for exclude in exclude_dirs: + if exclude in dirnames: + dirnames.remove(exclude) + for filename in filenames: + fullpath = os.path.join(dirpath, filename) + print_debug("testing: %s" % fullpath) + if is_python(fullpath): + yield fullpath + else: + print_debug(" unknown type") + + +if __name__ == "__main__": + # Two simple examples/tests + for fullpath in walk_python_files(['.']): + print(fullpath) + print("----------") + for fullpath in walk_python_files(['.'], is_python=can_be_compiled): + print(fullpath) diff --git a/marketing/Tools/scripts/reindent-rst.py b/marketing/Tools/scripts/reindent-rst.py new file mode 100644 index 0000000000000000000000000000000000000000..25608af66ac2fcafb85d1f9924a0265bdf093c67 --- /dev/null +++ b/marketing/Tools/scripts/reindent-rst.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python3 + +# Make a reST file compliant to our pre-commit hook. +# Currently just remove trailing whitespace. + +import sys + +import patchcheck + +def main(argv=sys.argv): + patchcheck.normalize_docs_whitespace(argv[1:]) + +if __name__ == '__main__': + sys.exit(main()) diff --git a/marketing/Tools/scripts/reindent.py b/marketing/Tools/scripts/reindent.py new file mode 100644 index 0000000000000000000000000000000000000000..f6dadaac5a52060d7f76fafddd4c4d1448ba4246 --- /dev/null +++ b/marketing/Tools/scripts/reindent.py @@ -0,0 +1,333 @@ +#! /usr/bin/env python3 + +# Released to the public domain, by Tim Peters, 03 October 2000. + +"""reindent [-d][-r][-v] [ path ... ] + +-d (--dryrun) Dry run. Analyze, but don't make any changes to, files. +-r (--recurse) Recurse. Search for all .py files in subdirectories too. +-n (--nobackup) No backup. Does not make a ".bak" file before reindenting. +-v (--verbose) Verbose. Print informative msgs; else no output. + (--newline) Newline. Specify the newline character to use (CRLF, LF). + Default is the same as the original file. +-h (--help) Help. Print this usage information and exit. + +Change Python (.py) files to use 4-space indents and no hard tab characters. +Also trim excess spaces and tabs from ends of lines, and remove empty lines +at the end of files. Also ensure the last line ends with a newline. + +If no paths are given on the command line, reindent operates as a filter, +reading a single source file from standard input and writing the transformed +source to standard output. In this case, the -d, -r and -v flags are +ignored. + +You can pass one or more file and/or directory paths. When a directory +path, all .py files within the directory will be examined, and, if the -r +option is given, likewise recursively for subdirectories. + +If output is not to standard output, reindent overwrites files in place, +renaming the originals with a .bak extension. If it finds nothing to +change, the file is left alone. If reindent does change a file, the changed +file is a fixed-point for future runs (i.e., running reindent on the +resulting .py file won't change it again). + +The hard part of reindenting is figuring out what to do with comment +lines. So long as the input files get a clean bill of health from +tabnanny.py, reindent should do a good job. + +The backup file is a copy of the one that is being reindented. The ".bak" +file is generated with shutil.copy(), but some corner cases regarding +user/group and permissions could leave the backup file more readable than +you'd prefer. You can always use the --nobackup option to prevent this. +""" + +__version__ = "1" + +import tokenize +import os +import shutil +import sys + +verbose = False +recurse = False +dryrun = False +makebackup = True +# A specified newline to be used in the output (set by --newline option) +spec_newline = None + + +def usage(msg=None): + if msg is None: + msg = __doc__ + print(msg, file=sys.stderr) + + +def errprint(*args): + sys.stderr.write(" ".join(str(arg) for arg in args)) + sys.stderr.write("\n") + +def main(): + import getopt + global verbose, recurse, dryrun, makebackup, spec_newline + try: + opts, args = getopt.getopt(sys.argv[1:], "drnvh", + ["dryrun", "recurse", "nobackup", "verbose", "newline=", "help"]) + except getopt.error as msg: + usage(msg) + return + for o, a in opts: + if o in ('-d', '--dryrun'): + dryrun = True + elif o in ('-r', '--recurse'): + recurse = True + elif o in ('-n', '--nobackup'): + makebackup = False + elif o in ('-v', '--verbose'): + verbose = True + elif o in ('--newline',): + if not a.upper() in ('CRLF', 'LF'): + usage() + return + spec_newline = dict(CRLF='\r\n', LF='\n')[a.upper()] + elif o in ('-h', '--help'): + usage() + return + if not args: + r = Reindenter(sys.stdin) + r.run() + r.write(sys.stdout) + return + for arg in args: + check(arg) + + +def check(file): + if os.path.isdir(file) and not os.path.islink(file): + if verbose: + print("listing directory", file) + names = os.listdir(file) + for name in names: + fullname = os.path.join(file, name) + if ((recurse and os.path.isdir(fullname) and + not os.path.islink(fullname) and + not os.path.split(fullname)[1].startswith(".")) + or name.lower().endswith(".py")): + check(fullname) + return + + if verbose: + print("checking", file, "...", end=' ') + with open(file, 'rb') as f: + try: + encoding, _ = tokenize.detect_encoding(f.readline) + except SyntaxError as se: + errprint("%s: SyntaxError: %s" % (file, str(se))) + return + try: + with open(file, encoding=encoding) as f: + r = Reindenter(f) + except IOError as msg: + errprint("%s: I/O Error: %s" % (file, str(msg))) + return + + newline = spec_newline if spec_newline else r.newlines + if isinstance(newline, tuple): + errprint("%s: mixed newlines detected; cannot continue without --newline" % file) + return + + if r.run(): + if verbose: + print("changed.") + if dryrun: + print("But this is a dry run, so leaving it alone.") + if not dryrun: + bak = file + ".bak" + if makebackup: + shutil.copyfile(file, bak) + if verbose: + print("backed up", file, "to", bak) + with open(file, "w", encoding=encoding, newline=newline) as f: + r.write(f) + if verbose: + print("wrote new", file) + return True + else: + if verbose: + print("unchanged.") + return False + + +def _rstrip(line, JUNK='\n \t'): + """Return line stripped of trailing spaces, tabs, newlines. + + Note that line.rstrip() instead also strips sundry control characters, + but at least one known Emacs user expects to keep junk like that, not + mentioning Barry by name or anything . + """ + + i = len(line) + while i > 0 and line[i - 1] in JUNK: + i -= 1 + return line[:i] + + +class Reindenter: + + def __init__(self, f): + self.find_stmt = 1 # next token begins a fresh stmt? + self.level = 0 # current indent level + + # Raw file lines. + self.raw = f.readlines() + + # File lines, rstripped & tab-expanded. Dummy at start is so + # that we can use tokenize's 1-based line numbering easily. + # Note that a line is all-blank iff it's "\n". + self.lines = [_rstrip(line).expandtabs() + "\n" + for line in self.raw] + self.lines.insert(0, None) + self.index = 1 # index into self.lines of next line + + # List of (lineno, indentlevel) pairs, one for each stmt and + # comment line. indentlevel is -1 for comment lines, as a + # signal that tokenize doesn't know what to do about them; + # indeed, they're our headache! + self.stats = [] + + # Save the newlines found in the file so they can be used to + # create output without mutating the newlines. + self.newlines = f.newlines + + def run(self): + tokens = tokenize.generate_tokens(self.getline) + for _token in tokens: + self.tokeneater(*_token) + # Remove trailing empty lines. + lines = self.lines + while lines and lines[-1] == "\n": + lines.pop() + # Sentinel. + stats = self.stats + stats.append((len(lines), 0)) + # Map count of leading spaces to # we want. + have2want = {} + # Program after transformation. + after = self.after = [] + # Copy over initial empty lines -- there's nothing to do until + # we see a line with *something* on it. + i = stats[0][0] + after.extend(lines[1:i]) + for i in range(len(stats) - 1): + thisstmt, thislevel = stats[i] + nextstmt = stats[i + 1][0] + have = getlspace(lines[thisstmt]) + want = thislevel * 4 + if want < 0: + # A comment line. + if have: + # An indented comment line. If we saw the same + # indentation before, reuse what it most recently + # mapped to. + want = have2want.get(have, -1) + if want < 0: + # Then it probably belongs to the next real stmt. + for j in range(i + 1, len(stats) - 1): + jline, jlevel = stats[j] + if jlevel >= 0: + if have == getlspace(lines[jline]): + want = jlevel * 4 + break + if want < 0: # Maybe it's a hanging + # comment like this one, + # in which case we should shift it like its base + # line got shifted. + for j in range(i - 1, -1, -1): + jline, jlevel = stats[j] + if jlevel >= 0: + want = have + (getlspace(after[jline - 1]) - + getlspace(lines[jline])) + break + if want < 0: + # Still no luck -- leave it alone. + want = have + else: + want = 0 + assert want >= 0 + have2want[have] = want + diff = want - have + if diff == 0 or have == 0: + after.extend(lines[thisstmt:nextstmt]) + else: + for line in lines[thisstmt:nextstmt]: + if diff > 0: + if line == "\n": + after.append(line) + else: + after.append(" " * diff + line) + else: + remove = min(getlspace(line), -diff) + after.append(line[remove:]) + return self.raw != self.after + + def write(self, f): + f.writelines(self.after) + + # Line-getter for tokenize. + def getline(self): + if self.index >= len(self.lines): + line = "" + else: + line = self.lines[self.index] + self.index += 1 + return line + + # Line-eater for tokenize. + def tokeneater(self, type, token, slinecol, end, line, + INDENT=tokenize.INDENT, + DEDENT=tokenize.DEDENT, + NEWLINE=tokenize.NEWLINE, + COMMENT=tokenize.COMMENT, + NL=tokenize.NL): + + if type == NEWLINE: + # A program statement, or ENDMARKER, will eventually follow, + # after some (possibly empty) run of tokens of the form + # (NL | COMMENT)* (INDENT | DEDENT+)? + self.find_stmt = 1 + + elif type == INDENT: + self.find_stmt = 1 + self.level += 1 + + elif type == DEDENT: + self.find_stmt = 1 + self.level -= 1 + + elif type == COMMENT: + if self.find_stmt: + self.stats.append((slinecol[0], -1)) + # but we're still looking for a new stmt, so leave + # find_stmt alone + + elif type == NL: + pass + + elif self.find_stmt: + # This is the first "real token" following a NEWLINE, so it + # must be the first token of the next program statement, or an + # ENDMARKER. + self.find_stmt = 0 + if line: # not endmarker + self.stats.append((slinecol[0], self.level)) + + +# Count number of leading blanks. +def getlspace(line): + i, n = 0, len(line) + while i < n and line[i] == " ": + i += 1 + return i + + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/rgrep.py b/marketing/Tools/scripts/rgrep.py new file mode 100644 index 0000000000000000000000000000000000000000..c39bf93aad3bb235b962175a9a80a7c69b48b577 --- /dev/null +++ b/marketing/Tools/scripts/rgrep.py @@ -0,0 +1,67 @@ +#! /usr/bin/env python3 + +"""Reverse grep. + +Usage: rgrep [-i] pattern file +""" + +import sys +import re +import getopt + + +def main(): + bufsize = 64 * 1024 + reflags = 0 + opts, args = getopt.getopt(sys.argv[1:], "i") + for o, a in opts: + if o == '-i': + reflags = reflags | re.IGNORECASE + if len(args) < 2: + usage("not enough arguments") + if len(args) > 2: + usage("exactly one file argument required") + pattern, filename = args + try: + prog = re.compile(pattern, reflags) + except re.error as msg: + usage("error in regular expression: %s" % msg) + try: + f = open(filename) + except IOError as msg: + usage("can't open %r: %s" % (filename, msg), 1) + with f: + f.seek(0, 2) + pos = f.tell() + leftover = None + while pos > 0: + size = min(pos, bufsize) + pos = pos - size + f.seek(pos) + buffer = f.read(size) + lines = buffer.split("\n") + del buffer + if leftover is None: + if not lines[-1]: + del lines[-1] + else: + lines[-1] = lines[-1] + leftover + if pos > 0: + leftover = lines[0] + del lines[0] + else: + leftover = None + for line in reversed(lines): + if prog.search(line): + print(line) + + +def usage(msg, code=2): + sys.stdout = sys.stderr + print(msg) + print(__doc__) + sys.exit(code) + + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/run_tests.py b/marketing/Tools/scripts/run_tests.py new file mode 100644 index 0000000000000000000000000000000000000000..bcfa5e943b347d59c035278b1c473eb37bc7a96d --- /dev/null +++ b/marketing/Tools/scripts/run_tests.py @@ -0,0 +1,55 @@ +"""Run Python's test suite in a fast, rigorous way. + +The defaults are meant to be reasonably thorough, while skipping certain +tests that can be time-consuming or resource-intensive (e.g. largefile), +or distracting (e.g. audio and gui). These defaults can be overridden by +simply passing a -u option to this script. + +""" + +import os +import sys +import test.support + + +def is_multiprocess_flag(arg): + return arg.startswith('-j') or arg.startswith('--multiprocess') + + +def is_resource_use_flag(arg): + return arg.startswith('-u') or arg.startswith('--use') + + +def main(regrtest_args): + args = [sys.executable, + '-u', # Unbuffered stdout and stderr + '-W', 'default', # Warnings set to 'default' + '-bb', # Warnings about bytes/bytearray + ] + if 'PYTHONOLDPARSER' not in os.environ: + args.append('-E') # Ignore environment variables + + # Allow user-specified interpreter options to override our defaults. + args.extend(test.support.args_from_interpreter_flags()) + + args.extend(['-m', 'test', # Run the test suite + '-r', # Randomize test order + '-w', # Re-run failed tests in verbose mode + ]) + if sys.platform == 'win32': + args.append('-n') # Silence alerts under Windows + if not any(is_multiprocess_flag(arg) for arg in regrtest_args): + args.extend(['-j', '0']) # Use all CPU cores + if not any(is_resource_use_flag(arg) for arg in regrtest_args): + args.extend(['-u', 'all,-largefile,-audio,-gui']) + args.extend(regrtest_args) + print(' '.join(args)) + if sys.platform == 'win32': + from subprocess import call + sys.exit(call(args)) + else: + os.execv(sys.executable, args) + + +if __name__ == '__main__': + main(sys.argv[1:]) diff --git a/marketing/Tools/scripts/serve.py b/marketing/Tools/scripts/serve.py new file mode 100644 index 0000000000000000000000000000000000000000..7ac9c105078329b813f5884fb52f6599adfc5aee --- /dev/null +++ b/marketing/Tools/scripts/serve.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 +''' +Small wsgiref based web server. Takes a path to serve from and an +optional port number (defaults to 8000), then tries to serve files. +Mime types are guessed from the file names, 404 errors are raised +if the file is not found. Used for the make serve target in Doc. +''' +import sys +import os +import mimetypes +from wsgiref import simple_server, util + +def app(environ, respond): + + fn = os.path.join(path, environ['PATH_INFO'][1:]) + if '.' not in fn.split(os.path.sep)[-1]: + fn = os.path.join(fn, 'index.html') + type = mimetypes.guess_type(fn)[0] + + if os.path.exists(fn): + respond('200 OK', [('Content-Type', type)]) + return util.FileWrapper(open(fn, "rb")) + else: + respond('404 Not Found', [('Content-Type', 'text/plain')]) + return [b'not found'] + +if __name__ == '__main__': + path = sys.argv[1] if len(sys.argv) > 1 else os.getcwd() + port = int(sys.argv[2]) if len(sys.argv) > 2 else 8000 + httpd = simple_server.make_server('', port, app) + print("Serving {} on port {}, control-C to stop".format(path, port)) + try: + httpd.serve_forever() + except KeyboardInterrupt: + print("Shutting down.") + httpd.server_close() diff --git a/marketing/Tools/scripts/smelly.py b/marketing/Tools/scripts/smelly.py new file mode 100644 index 0000000000000000000000000000000000000000..43d091654d2dc84e499e1950cc3a0303879d4d33 --- /dev/null +++ b/marketing/Tools/scripts/smelly.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python +# Script checking that all symbols exported by libpython start with Py or _Py + +import subprocess +import sys +import sysconfig + + +def get_exported_symbols(): + LIBRARY = sysconfig.get_config_var('LIBRARY') + if not LIBRARY: + raise Exception("failed to get LIBRARY") + + args = ('nm', '-p', LIBRARY) + print("+ %s" % ' '.join(args)) + proc = subprocess.run(args, stdout=subprocess.PIPE, universal_newlines=True) + if proc.returncode: + sys.stdout.write(proc.stdout) + sys.exit(proc.returncode) + + stdout = proc.stdout.rstrip() + if not stdout: + raise Exception("command output is empty") + return stdout + + +def get_smelly_symbols(stdout): + symbols = [] + ignored_symtypes = set() + + allowed_prefixes = ('Py', '_Py') + if sys.platform == 'darwin': + allowed_prefixes += ('__Py',) + + for line in stdout.splitlines(): + # Split line '0000000000001b80 D PyTextIOWrapper_Type' + if not line: + continue + + parts = line.split(maxsplit=2) + if len(parts) < 3: + continue + + symtype = parts[1].strip() + # Ignore private symbols. + # + # If lowercase, the symbol is usually local; if uppercase, the symbol + # is global (external). There are however a few lowercase symbols that + # are shown for special global symbols ("u", "v" and "w"). + if symtype.islower() and symtype not in "uvw": + ignored_symtypes.add(symtype) + continue + + symbol = parts[-1] + if symbol.startswith(allowed_prefixes): + continue + symbol = '%s (type: %s)' % (symbol, symtype) + symbols.append(symbol) + + if ignored_symtypes: + print("Ignored symbol types: %s" % ', '.join(sorted(ignored_symtypes))) + print() + return symbols + + +def main(): + nm_output = get_exported_symbols() + symbols = get_smelly_symbols(nm_output) + + if not symbols: + print("OK: no smelly symbol found") + sys.exit(0) + + symbols.sort() + for symbol in symbols: + print("Smelly symbol: %s" % symbol) + print() + print("ERROR: Found %s smelly symbols!" % len(symbols)) + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/marketing/Tools/scripts/suff.py b/marketing/Tools/scripts/suff.py new file mode 100644 index 0000000000000000000000000000000000000000..0eea0d7548611c16adc2ddb57d35f6de24c08a11 --- /dev/null +++ b/marketing/Tools/scripts/suff.py @@ -0,0 +1,26 @@ +#! /usr/bin/env python3 + +# suff +# +# show different suffixes amongst arguments + +import sys + + +def main(): + files = sys.argv[1:] + suffixes = {} + for filename in files: + suff = getsuffix(filename) + suffixes.setdefault(suff, []).append(filename) + for suff, filenames in sorted(suffixes.items()): + print(repr(suff), len(filenames)) + + +def getsuffix(filename): + name, sep, suff = filename.rpartition('.') + return sep + suff if sep else '' + + +if __name__ == '__main__': + main() diff --git a/marketing/Tools/scripts/texi2html.py b/marketing/Tools/scripts/texi2html.py new file mode 100644 index 0000000000000000000000000000000000000000..c06d812ab3fbc01e734414bc55d3453e001a9515 --- /dev/null +++ b/marketing/Tools/scripts/texi2html.py @@ -0,0 +1,2071 @@ +#! /usr/bin/env python3 + +# Convert GNU texinfo files into HTML, one file per node. +# Based on Texinfo 2.14. +# Usage: texi2html [-d] [-d] [-c] inputfile outputdirectory +# The input file must be a complete texinfo file, e.g. emacs.texi. +# This creates many files (one per info node) in the output directory, +# overwriting existing files of the same name. All files created have +# ".html" as their extension. + + +# XXX To do: +# - handle @comment*** correctly +# - handle @xref {some words} correctly +# - handle @ftable correctly (items aren't indexed?) +# - handle @itemx properly +# - handle @exdent properly +# - add links directly to the proper line from indices +# - check against the definitive list of @-cmds; we still miss (among others): +# - @defindex (hard) +# - @c(omment) in the middle of a line (rarely used) +# - @this* (not really needed, only used in headers anyway) +# - @today{} (ever used outside title page?) + +# More consistent handling of chapters/sections/etc. +# Lots of documentation +# Many more options: +# -top designate top node +# -links customize which types of links are included +# -split split at chapters or sections instead of nodes +# -name Allow different types of filename handling. Non unix systems +# will have problems with long node names +# ... +# Support the most recent texinfo version and take a good look at HTML 3.0 +# More debugging output (customizable) and more flexible error handling +# How about icons ? + +# rpyron 2002-05-07 +# Robert Pyron +# 1. BUGFIX: In function makefile(), strip blanks from the nodename. +# This is necessary to match the behavior of parser.makeref() and +# parser.do_node(). +# 2. BUGFIX fixed KeyError in end_ifset (well, I may have just made +# it go away, rather than fix it) +# 3. BUGFIX allow @menu and menu items inside @ifset or @ifclear +# 4. Support added for: +# @uref URL reference +# @image image file reference (see note below) +# @multitable output an HTML table +# @vtable +# 5. Partial support for accents, to match MAKEINFO output +# 6. I added a new command-line option, '-H basename', to specify +# HTML Help output. This will cause three files to be created +# in the current directory: +# `basename`.hhp HTML Help Workshop project file +# `basename`.hhc Contents file for the project +# `basename`.hhk Index file for the project +# When fed into HTML Help Workshop, the resulting file will be +# named `basename`.chm. +# 7. A new class, HTMLHelp, to accomplish item 6. +# 8. Various calls to HTMLHelp functions. +# A NOTE ON IMAGES: Just as 'outputdirectory' must exist before +# running this program, all referenced images must already exist +# in outputdirectory. + +import os +import sys +import string +import re + +MAGIC = '\\input texinfo' + +cmprog = re.compile('^@([a-z]+)([ \t]|$)') # Command (line-oriented) +blprog = re.compile('^[ \t]*$') # Blank line +kwprog = re.compile('@[a-z]+') # Keyword (embedded, usually + # with {} args) +spprog = re.compile('[\n@{}&<>]') # Special characters in + # running text + # + # menu item (Yuck!) +miprog = re.compile(r'^\* ([^:]*):(:|[ \t]*([^\t,\n.]+)([^ \t\n]*))[ \t\n]*') +# 0 1 1 2 3 34 42 0 +# ----- ---------- --------- +# -|----------------------------- +# ----------------------------------------------------- + + + + +class HTMLNode: + """Some of the parser's functionality is separated into this class. + + A Node accumulates its contents, takes care of links to other Nodes + and saves itself when it is finished and all links are resolved. + """ + + DOCTYPE = '' + + type = 0 + cont = '' + epilogue = '\n' + + def __init__(self, dir, name, topname, title, next, prev, up): + self.dirname = dir + self.name = name + if topname: + self.topname = topname + else: + self.topname = name + self.title = title + self.next = next + self.prev = prev + self.up = up + self.lines = [] + + def write(self, *lines): + for line in lines: + self.lines.append(line) + + def flush(self): + with open(self.dirname + '/' + makefile(self.name), 'w') as fp: + fp.write(self.prologue) + fp.write(self.text) + fp.write(self.epilogue) + + def link(self, label, nodename, rel=None, rev=None): + if nodename: + if nodename.lower() == '(dir)': + addr = '../dir.html' + title = '' + else: + addr = makefile(nodename) + title = ' TITLE="%s"' % nodename + self.write(label, ': ', nodename, ' \n') + + def finalize(self): + length = len(self.lines) + self.text = ''.join(self.lines) + self.lines = [] + self.open_links() + self.output_links() + self.close_links() + links = ''.join(self.lines) + self.lines = [] + self.prologue = ( + self.DOCTYPE + + '\n\n' + ' \n' + ' ' + self.title + '\n' + ' \n' + ' \n' + ' \n' + '\n' + + links) + if length > 20: + self.epilogue = '

\n%s\n' % links + + def open_links(self): + self.write('

\n') + + def close_links(self): + self.write('
\n') + + def output_links(self): + if self.cont != self.next: + self.link(' Cont', self.cont) + self.link(' Next', self.next, rel='Next') + self.link(' Prev', self.prev, rel='Previous') + self.link(' Up', self.up, rel='Up') + if self.name != self.topname: + self.link(' Top', self.topname) + + +class HTML3Node(HTMLNode): + + DOCTYPE = '' + + def open_links(self): + self.write('
\n
\n') + + def close_links(self): + self.write('
\n
\n') + + +class TexinfoParser: + + COPYRIGHT_SYMBOL = "©" + FN_ID_PATTERN = "(%(id)s)" + FN_SOURCE_PATTERN = '' \ + + FN_ID_PATTERN + '' + FN_TARGET_PATTERN = '' \ + + FN_ID_PATTERN + '\n%(text)s

\n' + FN_HEADER = '\n

\n

\n' \ + 'Footnotes\n

' + + + Node = HTMLNode + + # Initialize an instance + def __init__(self): + self.unknown = {} # statistics about unknown @-commands + self.filenames = {} # Check for identical filenames + self.debugging = 0 # larger values produce more output + self.print_headers = 0 # always print headers? + self.nodefp = None # open file we're writing to + self.nodelineno = 0 # Linenumber relative to node + self.links = None # Links from current node + self.savetext = None # If not None, save text head instead + self.savestack = [] # If not None, save text head instead + self.htmlhelp = None # html help data + self.dirname = 'tmp' # directory where files are created + self.includedir = '.' # directory to search @include files + self.nodename = '' # name of current node + self.topname = '' # name of top node (first node seen) + self.title = '' # title of this whole Texinfo tree + self.resetindex() # Reset all indices + self.contents = [] # Reset table of contents + self.numbering = [] # Reset section numbering counters + self.nofill = 0 # Normal operation: fill paragraphs + self.values={'html': 1} # Names that should be parsed in ifset + self.stackinfo={} # Keep track of state in the stack + # XXX The following should be reset per node?! + self.footnotes = [] # Reset list of footnotes + self.itemarg = None # Reset command used by @item + self.itemnumber = None # Reset number for @item in @enumerate + self.itemindex = None # Reset item index name + self.node = None + self.nodestack = [] + self.cont = 0 + self.includedepth = 0 + + # Set htmlhelp helper class + def sethtmlhelp(self, htmlhelp): + self.htmlhelp = htmlhelp + + # Set (output) directory name + def setdirname(self, dirname): + self.dirname = dirname + + # Set include directory name + def setincludedir(self, includedir): + self.includedir = includedir + + # Parse the contents of an entire file + def parse(self, fp): + line = fp.readline() + lineno = 1 + while line and (line[0] == '%' or blprog.match(line)): + line = fp.readline() + lineno = lineno + 1 + if line[:len(MAGIC)] != MAGIC: + raise SyntaxError('file does not begin with %r' % (MAGIC,)) + self.parserest(fp, lineno) + + # Parse the contents of a file, not expecting a MAGIC header + def parserest(self, fp, initial_lineno): + lineno = initial_lineno + self.done = 0 + self.skip = 0 + self.stack = [] + accu = [] + while not self.done: + line = fp.readline() + self.nodelineno = self.nodelineno + 1 + if not line: + if accu: + if not self.skip: self.process(accu) + accu = [] + if initial_lineno > 0: + print('*** EOF before @bye') + break + lineno = lineno + 1 + mo = cmprog.match(line) + if mo: + a, b = mo.span(1) + cmd = line[a:b] + if cmd in ('noindent', 'refill'): + accu.append(line) + else: + if accu: + if not self.skip: + self.process(accu) + accu = [] + self.command(line, mo) + elif blprog.match(line) and \ + 'format' not in self.stack and \ + 'example' not in self.stack: + if accu: + if not self.skip: + self.process(accu) + if self.nofill: + self.write('\n') + else: + self.write('

\n') + accu = [] + else: + # Append the line including trailing \n! + accu.append(line) + # + if self.skip: + print('*** Still skipping at the end') + if self.stack: + print('*** Stack not empty at the end') + print('***', self.stack) + if self.includedepth == 0: + while self.nodestack: + self.nodestack[-1].finalize() + self.nodestack[-1].flush() + del self.nodestack[-1] + + # Start saving text in a buffer instead of writing it to a file + def startsaving(self): + if self.savetext is not None: + self.savestack.append(self.savetext) + # print '*** Recursively saving text, expect trouble' + self.savetext = '' + + # Return the text saved so far and start writing to file again + def collectsavings(self): + savetext = self.savetext + if len(self.savestack) > 0: + self.savetext = self.savestack[-1] + del self.savestack[-1] + else: + self.savetext = None + return savetext or '' + + # Write text to file, or save it in a buffer, or ignore it + def write(self, *args): + try: + text = ''.join(args) + except: + print(args) + raise TypeError + if self.savetext is not None: + self.savetext = self.savetext + text + elif self.nodefp: + self.nodefp.write(text) + elif self.node: + self.node.write(text) + + # Complete the current node -- write footnotes and close file + def endnode(self): + if self.savetext is not None: + print('*** Still saving text at end of node') + dummy = self.collectsavings() + if self.footnotes: + self.writefootnotes() + if self.nodefp: + if self.nodelineno > 20: + self.write('

\n') + [name, next, prev, up] = self.nodelinks[:4] + self.link('Next', next) + self.link('Prev', prev) + self.link('Up', up) + if self.nodename != self.topname: + self.link('Top', self.topname) + self.write('
\n') + self.write('\n') + self.nodefp.close() + self.nodefp = None + elif self.node: + if not self.cont and \ + (not self.node.type or \ + (self.node.next and self.node.prev and self.node.up)): + self.node.finalize() + self.node.flush() + else: + self.nodestack.append(self.node) + self.node = None + self.nodename = '' + + # Process a list of lines, expanding embedded @-commands + # This mostly distinguishes between menus and normal text + def process(self, accu): + if self.debugging > 1: + print('!'*self.debugging, 'process:', self.skip, self.stack, end=' ') + if accu: print(accu[0][:30], end=' ') + if accu[0][30:] or accu[1:]: print('...', end=' ') + print() + if self.inmenu(): + # XXX should be done differently + for line in accu: + mo = miprog.match(line) + if not mo: + line = line.strip() + '\n' + self.expand(line) + continue + bgn, end = mo.span(0) + a, b = mo.span(1) + c, d = mo.span(2) + e, f = mo.span(3) + g, h = mo.span(4) + label = line[a:b] + nodename = line[c:d] + if nodename[0] == ':': nodename = label + else: nodename = line[e:f] + punct = line[g:h] + self.write('
  • ', nodename, + '', punct, '\n') + self.htmlhelp.menuitem(nodename) + self.expand(line[end:]) + else: + text = ''.join(accu) + self.expand(text) + + # find 'menu' (we might be inside 'ifset' or 'ifclear') + def inmenu(self): + #if 'menu' in self.stack: + # print 'inmenu :', self.skip, self.stack, self.stackinfo + stack = self.stack + while stack and stack[-1] in ('ifset','ifclear'): + try: + if self.stackinfo[len(stack)]: + return 0 + except KeyError: + pass + stack = stack[:-1] + return (stack and stack[-1] == 'menu') + + # Write a string, expanding embedded @-commands + def expand(self, text): + stack = [] + i = 0 + n = len(text) + while i < n: + start = i + mo = spprog.search(text, i) + if mo: + i = mo.start() + else: + self.write(text[start:]) + break + self.write(text[start:i]) + c = text[i] + i = i+1 + if c == '\n': + self.write('\n') + continue + if c == '<': + self.write('<') + continue + if c == '>': + self.write('>') + continue + if c == '&': + self.write('&') + continue + if c == '{': + stack.append('') + continue + if c == '}': + if not stack: + print('*** Unmatched }') + self.write('}') + continue + cmd = stack[-1] + del stack[-1] + try: + method = getattr(self, 'close_' + cmd) + except AttributeError: + self.unknown_close(cmd) + continue + method() + continue + if c != '@': + # Cannot happen unless spprog is changed + raise RuntimeError('unexpected funny %r' % c) + start = i + while i < n and text[i] in string.ascii_letters: i = i+1 + if i == start: + # @ plus non-letter: literal next character + i = i+1 + c = text[start:i] + if c == ':': + # `@:' means no extra space after + # preceding `.', `?', `!' or `:' + pass + else: + # `@.' means a sentence-ending period; + # `@@', `@{', `@}' quote `@', `{', `}' + self.write(c) + continue + cmd = text[start:i] + if i < n and text[i] == '{': + i = i+1 + stack.append(cmd) + try: + method = getattr(self, 'open_' + cmd) + except AttributeError: + self.unknown_open(cmd) + continue + method() + continue + try: + method = getattr(self, 'handle_' + cmd) + except AttributeError: + self.unknown_handle(cmd) + continue + method() + if stack: + print('*** Stack not empty at para:', stack) + + # --- Handle unknown embedded @-commands --- + + def unknown_open(self, cmd): + print('*** No open func for @' + cmd + '{...}') + cmd = cmd + '{' + self.write('@', cmd) + if cmd not in self.unknown: + self.unknown[cmd] = 1 + else: + self.unknown[cmd] = self.unknown[cmd] + 1 + + def unknown_close(self, cmd): + print('*** No close func for @' + cmd + '{...}') + cmd = '}' + cmd + self.write('}') + if cmd not in self.unknown: + self.unknown[cmd] = 1 + else: + self.unknown[cmd] = self.unknown[cmd] + 1 + + def unknown_handle(self, cmd): + print('*** No handler for @' + cmd) + self.write('@', cmd) + if cmd not in self.unknown: + self.unknown[cmd] = 1 + else: + self.unknown[cmd] = self.unknown[cmd] + 1 + + # XXX The following sections should be ordered as the texinfo docs + + # --- Embedded @-commands without {} argument list -- + + def handle_noindent(self): pass + + def handle_refill(self): pass + + # --- Include file handling --- + + def do_include(self, args): + file = args + file = os.path.join(self.includedir, file) + try: + fp = open(file, 'r') + except IOError as msg: + print('*** Can\'t open include file', repr(file)) + return + with fp: + print('!'*self.debugging, '--> file', repr(file)) + save_done = self.done + save_skip = self.skip + save_stack = self.stack + self.includedepth = self.includedepth + 1 + self.parserest(fp, 0) + self.includedepth = self.includedepth - 1 + self.done = save_done + self.skip = save_skip + self.stack = save_stack + print('!'*self.debugging, '<-- file', repr(file)) + + # --- Special Insertions --- + + def open_dmn(self): pass + def close_dmn(self): pass + + def open_dots(self): self.write('...') + def close_dots(self): pass + + def open_bullet(self): pass + def close_bullet(self): pass + + def open_TeX(self): self.write('TeX') + def close_TeX(self): pass + + def handle_copyright(self): self.write(self.COPYRIGHT_SYMBOL) + def open_copyright(self): self.write(self.COPYRIGHT_SYMBOL) + def close_copyright(self): pass + + def open_minus(self): self.write('-') + def close_minus(self): pass + + # --- Accents --- + + # rpyron 2002-05-07 + # I would like to do at least as well as makeinfo when + # it is producing HTML output: + # + # input output + # @"o @"o umlaut accent + # @'o 'o acute accent + # @,{c} @,{c} cedilla accent + # @=o @=o macron/overbar accent + # @^o @^o circumflex accent + # @`o `o grave accent + # @~o @~o tilde accent + # @dotaccent{o} @dotaccent{o} overdot accent + # @H{o} @H{o} long Hungarian umlaut + # @ringaccent{o} @ringaccent{o} ring accent + # @tieaccent{oo} @tieaccent{oo} tie-after accent + # @u{o} @u{o} breve accent + # @ubaraccent{o} @ubaraccent{o} underbar accent + # @udotaccent{o} @udotaccent{o} underdot accent + # @v{o} @v{o} hacek or check accent + # @exclamdown{} ¡ upside-down ! + # @questiondown{} ¿ upside-down ? + # @aa{},@AA{} å,Å a,A with circle + # @ae{},@AE{} æ,Æ ae,AE ligatures + # @dotless{i} @dotless{i} dotless i + # @dotless{j} @dotless{j} dotless j + # @l{},@L{} l/,L/ suppressed-L,l + # @o{},@O{} ø,Ø O,o with slash + # @oe{},@OE{} oe,OE oe,OE ligatures + # @ss{} ß es-zet or sharp S + # + # The following character codes and approximations have been + # copied from makeinfo's HTML output. + + def open_exclamdown(self): self.write('¡') # upside-down ! + def close_exclamdown(self): pass + def open_questiondown(self): self.write('¿') # upside-down ? + def close_questiondown(self): pass + def open_aa(self): self.write('å') # a with circle + def close_aa(self): pass + def open_AA(self): self.write('Å') # A with circle + def close_AA(self): pass + def open_ae(self): self.write('æ') # ae ligatures + def close_ae(self): pass + def open_AE(self): self.write('Æ') # AE ligatures + def close_AE(self): pass + def open_o(self): self.write('ø') # o with slash + def close_o(self): pass + def open_O(self): self.write('Ø') # O with slash + def close_O(self): pass + def open_ss(self): self.write('ß') # es-zet or sharp S + def close_ss(self): pass + def open_oe(self): self.write('oe') # oe ligatures + def close_oe(self): pass + def open_OE(self): self.write('OE') # OE ligatures + def close_OE(self): pass + def open_l(self): self.write('l/') # suppressed-l + def close_l(self): pass + def open_L(self): self.write('L/') # suppressed-L + def close_L(self): pass + + # --- Special Glyphs for Examples --- + + def open_result(self): self.write('=>') + def close_result(self): pass + + def open_expansion(self): self.write('==>') + def close_expansion(self): pass + + def open_print(self): self.write('-|') + def close_print(self): pass + + def open_error(self): self.write('error-->') + def close_error(self): pass + + def open_equiv(self): self.write('==') + def close_equiv(self): pass + + def open_point(self): self.write('-!-') + def close_point(self): pass + + # --- Cross References --- + + def open_pxref(self): + self.write('see ') + self.startsaving() + def close_pxref(self): + self.makeref() + + def open_xref(self): + self.write('See ') + self.startsaving() + def close_xref(self): + self.makeref() + + def open_ref(self): + self.startsaving() + def close_ref(self): + self.makeref() + + def open_inforef(self): + self.write('See info file ') + self.startsaving() + def close_inforef(self): + text = self.collectsavings() + args = [s.strip() for s in text.split(',')] + while len(args) < 3: args.append('') + node = args[0] + file = args[2] + self.write('`', file, '\', node `', node, '\'') + + def makeref(self): + text = self.collectsavings() + args = [s.strip() for s in text.split(',')] + while len(args) < 5: args.append('') + nodename = label = args[0] + if args[2]: label = args[2] + file = args[3] + title = args[4] + href = makefile(nodename) + if file: + href = '../' + file + '/' + href + self.write('', label, '') + + # rpyron 2002-05-07 uref support + def open_uref(self): + self.startsaving() + def close_uref(self): + text = self.collectsavings() + args = [s.strip() for s in text.split(',')] + while len(args) < 2: args.append('') + href = args[0] + label = args[1] + if not label: label = href + self.write('', label, '') + + # rpyron 2002-05-07 image support + # GNU makeinfo producing HTML output tries `filename.png'; if + # that does not exist, it tries `filename.jpg'. If that does + # not exist either, it complains. GNU makeinfo does not handle + # GIF files; however, I include GIF support here because + # MySQL documentation uses GIF files. + + def open_image(self): + self.startsaving() + def close_image(self): + self.makeimage() + def makeimage(self): + text = self.collectsavings() + args = [s.strip() for s in text.split(',')] + while len(args) < 5: args.append('') + filename = args[0] + width = args[1] + height = args[2] + alt = args[3] + ext = args[4] + + # The HTML output will have a reference to the image + # that is relative to the HTML output directory, + # which is what 'filename' gives us. However, we need + # to find it relative to our own current directory, + # so we construct 'imagename'. + imagelocation = self.dirname + '/' + filename + + if os.path.exists(imagelocation+'.png'): + filename += '.png' + elif os.path.exists(imagelocation+'.jpg'): + filename += '.jpg' + elif os.path.exists(imagelocation+'.gif'): # MySQL uses GIF files + filename += '.gif' + else: + print("*** Cannot find image " + imagelocation) + #TODO: what is 'ext'? + self.write('' ) + self.htmlhelp.addimage(imagelocation) + + + # --- Marking Words and Phrases --- + + # --- Other @xxx{...} commands --- + + def open_(self): pass # Used by {text enclosed in braces} + def close_(self): pass + + open_asis = open_ + close_asis = close_ + + def open_cite(self): self.write('') + def close_cite(self): self.write('') + + def open_code(self): self.write('') + def close_code(self): self.write('') + + def open_t(self): self.write('') + def close_t(self): self.write('') + + def open_dfn(self): self.write('') + def close_dfn(self): self.write('') + + def open_emph(self): self.write('') + def close_emph(self): self.write('') + + def open_i(self): self.write('') + def close_i(self): self.write('') + + def open_footnote(self): + # if self.savetext is not None: + # print '*** Recursive footnote -- expect weirdness' + id = len(self.footnotes) + 1 + self.write(self.FN_SOURCE_PATTERN % {'id': repr(id)}) + self.startsaving() + + def close_footnote(self): + id = len(self.footnotes) + 1 + self.footnotes.append((id, self.collectsavings())) + + def writefootnotes(self): + self.write(self.FN_HEADER) + for id, text in self.footnotes: + self.write(self.FN_TARGET_PATTERN + % {'id': repr(id), 'text': text}) + self.footnotes = [] + + def open_file(self): self.write('') + def close_file(self): self.write('') + + def open_kbd(self): self.write('') + def close_kbd(self): self.write('') + + def open_key(self): self.write('') + def close_key(self): self.write('') + + def open_r(self): self.write('') + def close_r(self): self.write('') + + def open_samp(self): self.write('`') + def close_samp(self): self.write('\'') + + def open_sc(self): self.write('') + def close_sc(self): self.write('') + + def open_strong(self): self.write('') + def close_strong(self): self.write('') + + def open_b(self): self.write('') + def close_b(self): self.write('') + + def open_var(self): self.write('') + def close_var(self): self.write('') + + def open_w(self): self.write('') + def close_w(self): self.write('') + + def open_url(self): self.startsaving() + def close_url(self): + text = self.collectsavings() + self.write('', text, '') + + def open_email(self): self.startsaving() + def close_email(self): + text = self.collectsavings() + self.write('', text, '') + + open_titlefont = open_ + close_titlefont = close_ + + def open_small(self): pass + def close_small(self): pass + + def command(self, line, mo): + a, b = mo.span(1) + cmd = line[a:b] + args = line[b:].strip() + if self.debugging > 1: + print('!'*self.debugging, 'command:', self.skip, self.stack, \ + '@' + cmd, args) + try: + func = getattr(self, 'do_' + cmd) + except AttributeError: + try: + func = getattr(self, 'bgn_' + cmd) + except AttributeError: + # don't complain if we are skipping anyway + if not self.skip: + self.unknown_cmd(cmd, args) + return + self.stack.append(cmd) + func(args) + return + if not self.skip or cmd == 'end': + func(args) + + def unknown_cmd(self, cmd, args): + print('*** unknown', '@' + cmd, args) + if cmd not in self.unknown: + self.unknown[cmd] = 1 + else: + self.unknown[cmd] = self.unknown[cmd] + 1 + + def do_end(self, args): + words = args.split() + if not words: + print('*** @end w/o args') + else: + cmd = words[0] + if not self.stack or self.stack[-1] != cmd: + print('*** @end', cmd, 'unexpected') + else: + del self.stack[-1] + try: + func = getattr(self, 'end_' + cmd) + except AttributeError: + self.unknown_end(cmd) + return + func() + + def unknown_end(self, cmd): + cmd = 'end ' + cmd + print('*** unknown', '@' + cmd) + if cmd not in self.unknown: + self.unknown[cmd] = 1 + else: + self.unknown[cmd] = self.unknown[cmd] + 1 + + # --- Comments --- + + def do_comment(self, args): pass + do_c = do_comment + + # --- Conditional processing --- + + def bgn_ifinfo(self, args): pass + def end_ifinfo(self): pass + + def bgn_iftex(self, args): self.skip = self.skip + 1 + def end_iftex(self): self.skip = self.skip - 1 + + def bgn_ignore(self, args): self.skip = self.skip + 1 + def end_ignore(self): self.skip = self.skip - 1 + + def bgn_tex(self, args): self.skip = self.skip + 1 + def end_tex(self): self.skip = self.skip - 1 + + def do_set(self, args): + fields = args.split(' ') + key = fields[0] + if len(fields) == 1: + value = 1 + else: + value = ' '.join(fields[1:]) + self.values[key] = value + + def do_clear(self, args): + self.values[args] = None + + def bgn_ifset(self, args): + if args not in self.values or self.values[args] is None: + self.skip = self.skip + 1 + self.stackinfo[len(self.stack)] = 1 + else: + self.stackinfo[len(self.stack)] = 0 + def end_ifset(self): + try: + if self.stackinfo[len(self.stack) + 1]: + self.skip = self.skip - 1 + del self.stackinfo[len(self.stack) + 1] + except KeyError: + print('*** end_ifset: KeyError :', len(self.stack) + 1) + + def bgn_ifclear(self, args): + if args in self.values and self.values[args] is not None: + self.skip = self.skip + 1 + self.stackinfo[len(self.stack)] = 1 + else: + self.stackinfo[len(self.stack)] = 0 + def end_ifclear(self): + try: + if self.stackinfo[len(self.stack) + 1]: + self.skip = self.skip - 1 + del self.stackinfo[len(self.stack) + 1] + except KeyError: + print('*** end_ifclear: KeyError :', len(self.stack) + 1) + + def open_value(self): + self.startsaving() + + def close_value(self): + key = self.collectsavings() + if key in self.values: + self.write(self.values[key]) + else: + print('*** Undefined value: ', key) + + # --- Beginning a file --- + + do_finalout = do_comment + do_setchapternewpage = do_comment + do_setfilename = do_comment + + def do_settitle(self, args): + self.startsaving() + self.expand(args) + self.title = self.collectsavings() + def do_parskip(self, args): pass + + # --- Ending a file --- + + def do_bye(self, args): + self.endnode() + self.done = 1 + + # --- Title page --- + + def bgn_titlepage(self, args): self.skip = self.skip + 1 + def end_titlepage(self): self.skip = self.skip - 1 + def do_shorttitlepage(self, args): pass + + def do_center(self, args): + # Actually not used outside title page... + self.write('

    ') + self.expand(args) + self.write('

    \n') + do_title = do_center + do_subtitle = do_center + do_author = do_center + + do_vskip = do_comment + do_vfill = do_comment + do_smallbook = do_comment + + do_paragraphindent = do_comment + do_setchapternewpage = do_comment + do_headings = do_comment + do_footnotestyle = do_comment + + do_evenheading = do_comment + do_evenfooting = do_comment + do_oddheading = do_comment + do_oddfooting = do_comment + do_everyheading = do_comment + do_everyfooting = do_comment + + # --- Nodes --- + + def do_node(self, args): + self.endnode() + self.nodelineno = 0 + parts = [s.strip() for s in args.split(',')] + while len(parts) < 4: parts.append('') + self.nodelinks = parts + [name, next, prev, up] = parts[:4] + file = self.dirname + '/' + makefile(name) + if file in self.filenames: + print('*** Filename already in use: ', file) + else: + if self.debugging: print('!'*self.debugging, '--- writing', file) + self.filenames[file] = 1 + # self.nodefp = open(file, 'w') + self.nodename = name + if self.cont and self.nodestack: + self.nodestack[-1].cont = self.nodename + if not self.topname: self.topname = name + title = name + if self.title: title = title + ' -- ' + self.title + self.node = self.Node(self.dirname, self.nodename, self.topname, + title, next, prev, up) + self.htmlhelp.addnode(self.nodename,next,prev,up,file) + + def link(self, label, nodename): + if nodename: + if nodename.lower() == '(dir)': + addr = '../dir.html' + else: + addr = makefile(nodename) + self.write(label, ': ', nodename, ' \n') + + # --- Sectioning commands --- + + def popstack(self, type): + if (self.node): + self.node.type = type + while self.nodestack: + if self.nodestack[-1].type > type: + self.nodestack[-1].finalize() + self.nodestack[-1].flush() + del self.nodestack[-1] + elif self.nodestack[-1].type == type: + if not self.nodestack[-1].next: + self.nodestack[-1].next = self.node.name + if not self.node.prev: + self.node.prev = self.nodestack[-1].name + self.nodestack[-1].finalize() + self.nodestack[-1].flush() + del self.nodestack[-1] + else: + if type > 1 and not self.node.up: + self.node.up = self.nodestack[-1].name + break + + def do_chapter(self, args): + self.heading('H1', args, 0) + self.popstack(1) + + def do_unnumbered(self, args): + self.heading('H1', args, -1) + self.popstack(1) + def do_appendix(self, args): + self.heading('H1', args, -1) + self.popstack(1) + def do_top(self, args): + self.heading('H1', args, -1) + def do_chapheading(self, args): + self.heading('H1', args, -1) + def do_majorheading(self, args): + self.heading('H1', args, -1) + + def do_section(self, args): + self.heading('H1', args, 1) + self.popstack(2) + + def do_unnumberedsec(self, args): + self.heading('H1', args, -1) + self.popstack(2) + def do_appendixsec(self, args): + self.heading('H1', args, -1) + self.popstack(2) + do_appendixsection = do_appendixsec + def do_heading(self, args): + self.heading('H1', args, -1) + + def do_subsection(self, args): + self.heading('H2', args, 2) + self.popstack(3) + def do_unnumberedsubsec(self, args): + self.heading('H2', args, -1) + self.popstack(3) + def do_appendixsubsec(self, args): + self.heading('H2', args, -1) + self.popstack(3) + def do_subheading(self, args): + self.heading('H2', args, -1) + + def do_subsubsection(self, args): + self.heading('H3', args, 3) + self.popstack(4) + def do_unnumberedsubsubsec(self, args): + self.heading('H3', args, -1) + self.popstack(4) + def do_appendixsubsubsec(self, args): + self.heading('H3', args, -1) + self.popstack(4) + def do_subsubheading(self, args): + self.heading('H3', args, -1) + + def heading(self, type, args, level): + if level >= 0: + while len(self.numbering) <= level: + self.numbering.append(0) + del self.numbering[level+1:] + self.numbering[level] = self.numbering[level] + 1 + x = '' + for i in self.numbering: + x = x + repr(i) + '.' + args = x + ' ' + args + self.contents.append((level, args, self.nodename)) + self.write('<', type, '>') + self.expand(args) + self.write('\n') + if self.debugging or self.print_headers: + print('---', args) + + def do_contents(self, args): + # pass + self.listcontents('Table of Contents', 999) + + def do_shortcontents(self, args): + pass + # self.listcontents('Short Contents', 0) + do_summarycontents = do_shortcontents + + def listcontents(self, title, maxlevel): + self.write('

    ', title, '

    \n
      \n') + prevlevels = [0] + for level, title, node in self.contents: + if level > maxlevel: + continue + if level > prevlevels[-1]: + # can only advance one level at a time + self.write(' '*prevlevels[-1], '
        \n') + prevlevels.append(level) + elif level < prevlevels[-1]: + # might drop back multiple levels + while level < prevlevels[-1]: + del prevlevels[-1] + self.write(' '*prevlevels[-1], + '
      \n') + self.write(' '*level, '
    • ') + self.expand(title) + self.write('\n') + self.write('
    \n' * len(prevlevels)) + + # --- Page lay-out --- + + # These commands are only meaningful in printed text + + def do_page(self, args): pass + + def do_need(self, args): pass + + def bgn_group(self, args): pass + def end_group(self): pass + + # --- Line lay-out --- + + def do_sp(self, args): + if self.nofill: + self.write('\n') + else: + self.write('

    \n') + + def do_hline(self, args): + self.write('

    ') + + # --- Function and variable definitions --- + + def bgn_deffn(self, args): + self.write('
    ') + self.do_deffnx(args) + + def end_deffn(self): + self.write('
    \n') + + def do_deffnx(self, args): + self.write('
    ') + words = splitwords(args, 2) + [category, name], rest = words[:2], words[2:] + self.expand('@b{%s}' % name) + for word in rest: self.expand(' ' + makevar(word)) + #self.expand(' -- ' + category) + self.write('\n
    ') + self.index('fn', name) + + def bgn_defun(self, args): self.bgn_deffn('Function ' + args) + end_defun = end_deffn + def do_defunx(self, args): self.do_deffnx('Function ' + args) + + def bgn_defmac(self, args): self.bgn_deffn('Macro ' + args) + end_defmac = end_deffn + def do_defmacx(self, args): self.do_deffnx('Macro ' + args) + + def bgn_defspec(self, args): self.bgn_deffn('{Special Form} ' + args) + end_defspec = end_deffn + def do_defspecx(self, args): self.do_deffnx('{Special Form} ' + args) + + def bgn_defvr(self, args): + self.write('
    ') + self.do_defvrx(args) + + end_defvr = end_deffn + + def do_defvrx(self, args): + self.write('
    ') + words = splitwords(args, 2) + [category, name], rest = words[:2], words[2:] + self.expand('@code{%s}' % name) + # If there are too many arguments, show them + for word in rest: self.expand(' ' + word) + #self.expand(' -- ' + category) + self.write('\n
    ') + self.index('vr', name) + + def bgn_defvar(self, args): self.bgn_defvr('Variable ' + args) + end_defvar = end_defvr + def do_defvarx(self, args): self.do_defvrx('Variable ' + args) + + def bgn_defopt(self, args): self.bgn_defvr('{User Option} ' + args) + end_defopt = end_defvr + def do_defoptx(self, args): self.do_defvrx('{User Option} ' + args) + + # --- Ditto for typed languages --- + + def bgn_deftypefn(self, args): + self.write('
    ') + self.do_deftypefnx(args) + + end_deftypefn = end_deffn + + def do_deftypefnx(self, args): + self.write('
    ') + words = splitwords(args, 3) + [category, datatype, name], rest = words[:3], words[3:] + self.expand('@code{%s} @b{%s}' % (datatype, name)) + for word in rest: self.expand(' ' + makevar(word)) + #self.expand(' -- ' + category) + self.write('\n
    ') + self.index('fn', name) + + + def bgn_deftypefun(self, args): self.bgn_deftypefn('Function ' + args) + end_deftypefun = end_deftypefn + def do_deftypefunx(self, args): self.do_deftypefnx('Function ' + args) + + def bgn_deftypevr(self, args): + self.write('
    ') + self.do_deftypevrx(args) + + end_deftypevr = end_deftypefn + + def do_deftypevrx(self, args): + self.write('
    ') + words = splitwords(args, 3) + [category, datatype, name], rest = words[:3], words[3:] + self.expand('@code{%s} @b{%s}' % (datatype, name)) + # If there are too many arguments, show them + for word in rest: self.expand(' ' + word) + #self.expand(' -- ' + category) + self.write('\n
    ') + self.index('fn', name) + + def bgn_deftypevar(self, args): + self.bgn_deftypevr('Variable ' + args) + end_deftypevar = end_deftypevr + def do_deftypevarx(self, args): + self.do_deftypevrx('Variable ' + args) + + # --- Ditto for object-oriented languages --- + + def bgn_defcv(self, args): + self.write('
    ') + self.do_defcvx(args) + + end_defcv = end_deftypevr + + def do_defcvx(self, args): + self.write('
    ') + words = splitwords(args, 3) + [category, classname, name], rest = words[:3], words[3:] + self.expand('@b{%s}' % name) + # If there are too many arguments, show them + for word in rest: self.expand(' ' + word) + #self.expand(' -- %s of @code{%s}' % (category, classname)) + self.write('\n
    ') + self.index('vr', '%s @r{on %s}' % (name, classname)) + + def bgn_defivar(self, args): + self.bgn_defcv('{Instance Variable} ' + args) + end_defivar = end_defcv + def do_defivarx(self, args): + self.do_defcvx('{Instance Variable} ' + args) + + def bgn_defop(self, args): + self.write('
    ') + self.do_defopx(args) + + end_defop = end_defcv + + def do_defopx(self, args): + self.write('
    ') + words = splitwords(args, 3) + [category, classname, name], rest = words[:3], words[3:] + self.expand('@b{%s}' % name) + for word in rest: self.expand(' ' + makevar(word)) + #self.expand(' -- %s of @code{%s}' % (category, classname)) + self.write('\n
    ') + self.index('fn', '%s @r{on %s}' % (name, classname)) + + def bgn_defmethod(self, args): + self.bgn_defop('Method ' + args) + end_defmethod = end_defop + def do_defmethodx(self, args): + self.do_defopx('Method ' + args) + + # --- Ditto for data types --- + + def bgn_deftp(self, args): + self.write('
    ') + self.do_deftpx(args) + + end_deftp = end_defcv + + def do_deftpx(self, args): + self.write('
    ') + words = splitwords(args, 2) + [category, name], rest = words[:2], words[2:] + self.expand('@b{%s}' % name) + for word in rest: self.expand(' ' + word) + #self.expand(' -- ' + category) + self.write('\n
    ') + self.index('tp', name) + + # --- Making Lists and Tables + + def bgn_enumerate(self, args): + if not args: + self.write('
      \n') + self.stackinfo[len(self.stack)] = '
    \n' + else: + self.itemnumber = args + self.write('
      \n') + self.stackinfo[len(self.stack)] = '
    \n' + def end_enumerate(self): + self.itemnumber = None + self.write(self.stackinfo[len(self.stack) + 1]) + del self.stackinfo[len(self.stack) + 1] + + def bgn_itemize(self, args): + self.itemarg = args + self.write('
      \n') + def end_itemize(self): + self.itemarg = None + self.write('
    \n') + + def bgn_table(self, args): + self.itemarg = args + self.write('
    \n') + def end_table(self): + self.itemarg = None + self.write('
    \n') + + def bgn_ftable(self, args): + self.itemindex = 'fn' + self.bgn_table(args) + def end_ftable(self): + self.itemindex = None + self.end_table() + + def bgn_vtable(self, args): + self.itemindex = 'vr' + self.bgn_table(args) + def end_vtable(self): + self.itemindex = None + self.end_table() + + def do_item(self, args): + if self.itemindex: self.index(self.itemindex, args) + if self.itemarg: + if self.itemarg[0] == '@' and self.itemarg[1] and \ + self.itemarg[1] in string.ascii_letters: + args = self.itemarg + '{' + args + '}' + else: + # some other character, e.g. '-' + args = self.itemarg + ' ' + args + if self.itemnumber is not None: + args = self.itemnumber + '. ' + args + self.itemnumber = increment(self.itemnumber) + if self.stack and self.stack[-1] == 'table': + self.write('
    ') + self.expand(args) + self.write('\n
    ') + elif self.stack and self.stack[-1] == 'multitable': + self.write('') + self.expand(args) + self.write('\n\n') + else: + self.write('
  • ') + self.expand(args) + self.write(' ') + do_itemx = do_item # XXX Should suppress leading blank line + + # rpyron 2002-05-07 multitable support + def bgn_multitable(self, args): + self.itemarg = None # should be handled by columnfractions + self.write('\n') + def end_multitable(self): + self.itemarg = None + self.write('
    \n
    \n') + def handle_columnfractions(self): + # It would be better to handle this, but for now it's in the way... + self.itemarg = None + def handle_tab(self): + self.write('\n ') + + # --- Enumerations, displays, quotations --- + # XXX Most of these should increase the indentation somehow + + def bgn_quotation(self, args): self.write('
    ') + def end_quotation(self): self.write('
    \n') + + def bgn_example(self, args): + self.nofill = self.nofill + 1 + self.write('
    ')
+    def end_example(self):
+        self.write('
    \n') + self.nofill = self.nofill - 1 + + bgn_lisp = bgn_example # Synonym when contents are executable lisp code + end_lisp = end_example + + bgn_smallexample = bgn_example # XXX Should use smaller font + end_smallexample = end_example + + bgn_smalllisp = bgn_lisp # Ditto + end_smalllisp = end_lisp + + bgn_display = bgn_example + end_display = end_example + + bgn_format = bgn_display + end_format = end_display + + def do_exdent(self, args): self.expand(args + '\n') + # XXX Should really mess with indentation + + def bgn_flushleft(self, args): + self.nofill = self.nofill + 1 + self.write('
    \n')
+    def end_flushleft(self):
+        self.write('
    \n') + self.nofill = self.nofill - 1 + + def bgn_flushright(self, args): + self.nofill = self.nofill + 1 + self.write('
    \n') + def end_flushright(self): + self.write('
    \n') + self.nofill = self.nofill - 1 + + def bgn_menu(self, args): + self.write('\n') + self.write(' Menu

    \n') + self.htmlhelp.beginmenu() + def end_menu(self): + self.write('

    \n') + self.htmlhelp.endmenu() + + def bgn_cartouche(self, args): pass + def end_cartouche(self): pass + + # --- Indices --- + + def resetindex(self): + self.noncodeindices = ['cp'] + self.indextitle = {} + self.indextitle['cp'] = 'Concept' + self.indextitle['fn'] = 'Function' + self.indextitle['ky'] = 'Keyword' + self.indextitle['pg'] = 'Program' + self.indextitle['tp'] = 'Type' + self.indextitle['vr'] = 'Variable' + # + self.whichindex = {} + for name in self.indextitle: + self.whichindex[name] = [] + + def user_index(self, name, args): + if name in self.whichindex: + self.index(name, args) + else: + print('*** No index named', repr(name)) + + def do_cindex(self, args): self.index('cp', args) + def do_findex(self, args): self.index('fn', args) + def do_kindex(self, args): self.index('ky', args) + def do_pindex(self, args): self.index('pg', args) + def do_tindex(self, args): self.index('tp', args) + def do_vindex(self, args): self.index('vr', args) + + def index(self, name, args): + self.whichindex[name].append((args, self.nodename)) + self.htmlhelp.index(args, self.nodename) + + def do_synindex(self, args): + words = args.split() + if len(words) != 2: + print('*** bad @synindex', args) + return + [old, new] = words + if old not in self.whichindex or \ + new not in self.whichindex: + print('*** bad key(s) in @synindex', args) + return + if old != new and \ + self.whichindex[old] is not self.whichindex[new]: + inew = self.whichindex[new] + inew[len(inew):] = self.whichindex[old] + self.whichindex[old] = inew + do_syncodeindex = do_synindex # XXX Should use code font + + def do_printindex(self, args): + words = args.split() + for name in words: + if name in self.whichindex: + self.prindex(name) + else: + print('*** No index named', repr(name)) + + def prindex(self, name): + iscodeindex = (name not in self.noncodeindices) + index = self.whichindex[name] + if not index: return + if self.debugging: + print('!'*self.debugging, '--- Generating', \ + self.indextitle[name], 'index') + # The node already provides a title + index1 = [] + junkprog = re.compile('^(@[a-z]+)?{') + for key, node in index: + sortkey = key.lower() + # Remove leading `@cmd{' from sort key + # -- don't bother about the matching `}' + oldsortkey = sortkey + while 1: + mo = junkprog.match(sortkey) + if not mo: + break + i = mo.end() + sortkey = sortkey[i:] + index1.append((sortkey, key, node)) + del index[:] + index1.sort() + self.write('
    \n') + prevkey = prevnode = None + for sortkey, key, node in index1: + if (key, node) == (prevkey, prevnode): + continue + if self.debugging > 1: print('!'*self.debugging, key, ':', node) + self.write('
    ') + if iscodeindex: key = '@code{' + key + '}' + if key != prevkey: + self.expand(key) + self.write('\n
    %s\n' % (makefile(node), node)) + prevkey, prevnode = key, node + self.write('
    \n') + + # --- Final error reports --- + + def report(self): + if self.unknown: + print('--- Unrecognized commands ---') + cmds = sorted(self.unknown.keys()) + for cmd in cmds: + print(cmd.ljust(20), self.unknown[cmd]) + + +class TexinfoParserHTML3(TexinfoParser): + + COPYRIGHT_SYMBOL = "©" + FN_ID_PATTERN = "[%(id)s]" + FN_SOURCE_PATTERN = '' + FN_ID_PATTERN + '' + FN_TARGET_PATTERN = '\n' \ + '

    ' + FN_ID_PATTERN \ + + '\n%(text)s

    \n' + FN_HEADER = '
    \n
    \n' \ + ' Footnotes\n

    \n' + + Node = HTML3Node + + def bgn_quotation(self, args): self.write('') + def end_quotation(self): self.write('\n') + + def bgn_example(self, args): + # this use of would not be legal in HTML 2.0, + # but is in more recent DTDs. + self.nofill = self.nofill + 1 + self.write('

    ')
+    def end_example(self):
+        self.write("
    \n") + self.nofill = self.nofill - 1 + + def bgn_flushleft(self, args): + self.nofill = self.nofill + 1 + self.write('
    \n')
+
+    def bgn_flushright(self, args):
+        self.nofill = self.nofill + 1
+        self.write('
    \n')
+    def end_flushright(self):
+        self.write('
    \n')
+        self.nofill = self.nofill - 1
+
+    def bgn_menu(self, args):
+        self.write('
      \n')
+        self.write('  Menu\n')
+    def end_menu(self):
+        self.write('
    \n')
+
+
+# rpyron 2002-05-07
+class HTMLHelp:
+    """
+    This class encapsulates support for HTML Help. Node names,
+    file names, menu items, index items, and image file names are
+    accumulated until a call to finalize(). At that time, three
+    output files are created in the current directory:
+
+        `helpbase`.hhp  is a HTML Help Workshop project file.
+                        It contains various information, some of
+                        which I do not understand; I just copied
+                        the default project info from a fresh
+                        installation.
+        `helpbase`.hhc  is the Contents file for the project.
+        `helpbase`.hhk  is the Index file for the project.
+
+    When these files are used as input to HTML Help Workshop,
+    the resulting file will be named:
+
+        `helpbase`.chm
+
+    If none of the defaults in `helpbase`.hhp are changed,
+    the .CHM file will have Contents, Index, Search, and
+    Favorites tabs.
+    """
+
+    codeprog = re.compile('@code{(.*?)}')
+
+    def __init__(self,helpbase,dirname):
+        self.helpbase    = helpbase
+        self.dirname     = dirname
+        self.projectfile = None
+        self.contentfile = None
+        self.indexfile   = None
+        self.nodelist    = []
+        self.nodenames   = {}         # nodename : index
+        self.nodeindex   = {}
+        self.filenames   = {}         # filename : filename
+        self.indexlist   = []         # (args,nodename) == (key,location)
+        self.current     = ''
+        self.menudict    = {}
+        self.dumped      = {}
+
+
+    def addnode(self,name,next,prev,up,filename):
+        node = (name,next,prev,up,filename)
+        # add this file to dict
+        # retrieve list with self.filenames.values()
+        self.filenames[filename] = filename
+        # add this node to nodelist
+        self.nodeindex[name] = len(self.nodelist)
+        self.nodelist.append(node)
+        # set 'current' for menu items
+        self.current = name
+        self.menudict[self.current] = []
+
+    def menuitem(self,nodename):
+        menu = self.menudict[self.current]
+        menu.append(nodename)
+
+
+    def addimage(self,imagename):
+        self.filenames[imagename] = imagename
+
+    def index(self, args, nodename):
+        self.indexlist.append((args,nodename))
+
+    def beginmenu(self):
+        pass
+
+    def endmenu(self):
+        pass
+
+    def finalize(self):
+        if not self.helpbase:
+            return
+
+        # generate interesting filenames
+        resultfile   = self.helpbase + '.chm'
+        projectfile  = self.helpbase + '.hhp'
+        contentfile  = self.helpbase + '.hhc'
+        indexfile    = self.helpbase + '.hhk'
+
+        # generate a reasonable title
+        title        = self.helpbase
+
+        # get the default topic file
+        (topname,topnext,topprev,topup,topfile) = self.nodelist[0]
+        defaulttopic = topfile
+
+        # PROJECT FILE
+        try:
+            with open(projectfile, 'w') as fp:
+                print('[OPTIONS]', file=fp)
+                print('Auto Index=Yes', file=fp)
+                print('Binary TOC=No', file=fp)
+                print('Binary Index=Yes', file=fp)
+                print('Compatibility=1.1', file=fp)
+                print('Compiled file=' + resultfile + '', file=fp)
+                print('Contents file=' + contentfile + '', file=fp)
+                print('Default topic=' + defaulttopic + '', file=fp)
+                print('Error log file=ErrorLog.log', file=fp)
+                print('Index file=' + indexfile + '', file=fp)
+                print('Title=' + title + '', file=fp)
+                print('Display compile progress=Yes', file=fp)
+                print('Full-text search=Yes', file=fp)
+                print('Default window=main', file=fp)
+                print('', file=fp)
+                print('[WINDOWS]', file=fp)
+                print('main=,"' + contentfile + '","' + indexfile
+                            + '","","",,,,,0x23520,222,0x1046,[10,10,780,560],'
+                            '0xB0000,,,,,,0', file=fp)
+                print('', file=fp)
+                print('[FILES]', file=fp)
+                print('', file=fp)
+                self.dumpfiles(fp)
+        except IOError as msg:
+            print(projectfile, ':', msg)
+            sys.exit(1)
+
+        # CONTENT FILE
+        try:
+            with open(contentfile, 'w') as fp:
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('   ', file=fp)
+                print('     ', file=fp)
+                print('     ', file=fp)
+                print('     ', file=fp)
+                print('   ', file=fp)
+                self.dumpnodes(fp)
+                print('', file=fp)
+                print('', file=fp)
+        except IOError as msg:
+            print(contentfile, ':', msg)
+            sys.exit(1)
+
+        # INDEX FILE
+        try:
+            with open(indexfile, 'w') as fp:
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                print('', file=fp)
+                self.dumpindex(fp)
+                print('', file=fp)
+                print('', file=fp)
+        except IOError as msg:
+            print(indexfile  , ':', msg)
+            sys.exit(1)
+
+    def dumpfiles(self, outfile=sys.stdout):
+        filelist = sorted(self.filenames.values())
+        for filename in filelist:
+            print(filename, file=outfile)
+
+    def dumpnodes(self, outfile=sys.stdout):
+        self.dumped = {}
+        if self.nodelist:
+            nodename, dummy, dummy, dummy, dummy = self.nodelist[0]
+            self.topnode = nodename
+
+        print('
      ', file=outfile)
+        for node in self.nodelist:
+            self.dumpnode(node,0,outfile)
+        print('
    ', file=outfile)
+
+    def dumpnode(self, node, indent=0, outfile=sys.stdout):
+        if node:
+            # Retrieve info for this node
+            (nodename,next,prev,up,filename) = node
+            self.current = nodename
+
+            # Have we been dumped already?
+            if nodename in self.dumped:
+                return
+            self.dumped[nodename] = 1
+
+            # Print info for this node
+            print(' '*indent, end=' ', file=outfile)
+            print('
  • ', end=' ', file=outfile)
+            print('', end=' ', file=outfile)
+            print('', end=' ', file=outfile)
+            print('', file=outfile)
+
+            # Does this node have menu items?
+            try:
+                menu = self.menudict[nodename]
+                self.dumpmenu(menu,indent+2,outfile)
+            except KeyError:
+                pass
+
+    def dumpmenu(self, menu, indent=0, outfile=sys.stdout):
+        if menu:
+            currentnode = self.current
+            if currentnode != self.topnode:    # XXX this is a hack
+                print(' '*indent + '
      ', file=outfile)
+                indent += 2
+            for item in menu:
+                menunode = self.getnode(item)
+                self.dumpnode(menunode,indent,outfile)
+            if currentnode != self.topnode:    # XXX this is a hack
+                print(' '*indent + '
    ', file=outfile)
+                indent -= 2
+
+    def getnode(self, nodename):
+        try:
+            index = self.nodeindex[nodename]
+            return self.nodelist[index]
+        except KeyError:
+            return None
+        except IndexError:
+            return None
+
+    # (args,nodename) == (key,location)
+    def dumpindex(self, outfile=sys.stdout):
+        print('
      ', file=outfile)
+        for (key,location) in self.indexlist:
+            key = self.codeexpand(key)
+            location = makefile(location)
+            location = self.dirname + '/' + location
+            print('
    • ', end=' ', file=outfile)
+            print('', end=' ', file=outfile)
+            print('', end=' ', file=outfile)
+            print('', file=outfile)
+        print('
    ', file=outfile)
+
+    def codeexpand(self, line):
+        co = self.codeprog.match(line)
+        if not co:
+            return line
+        bgn, end = co.span(0)
+        a, b = co.span(1)
+        line = line[:bgn] + line[a:b] + line[end:]
+        return line
+
+
+# Put @var{} around alphabetic substrings
+def makevar(str):
+    return '@var{'+str+'}'
+
+
+# Split a string in "words" according to findwordend
+def splitwords(str, minlength):
+    words = []
+    i = 0
+    n = len(str)
+    while i < n:
+        while i < n and str[i] in ' \t\n': i = i+1
+        if i >= n: break
+        start = i
+        i = findwordend(str, i, n)
+        words.append(str[start:i])
+    while len(words) < minlength: words.append('')
+    return words
+
+
+# Find the end of a "word", matching braces and interpreting @@ @{ @}
+fwprog = re.compile('[@{} ]')
+def findwordend(str, i, n):
+    level = 0
+    while i < n:
+        mo = fwprog.search(str, i)
+        if not mo:
+            break
+        i = mo.start()
+        c = str[i]; i = i+1
+        if c == '@': i = i+1 # Next character is not special
+        elif c == '{': level = level+1
+        elif c == '}': level = level-1
+        elif c == ' ' and level <= 0: return i-1
+    return n
+
+
+# Convert a node name into a file name
+def makefile(nodename):
+    nodename = nodename.strip()
+    return fixfunnychars(nodename) + '.html'
+
+
+# Characters that are perfectly safe in filenames and hyperlinks
+goodchars = string.ascii_letters + string.digits + '!@-=+.'
+
+# Replace characters that aren't perfectly safe by dashes
+# Underscores are bad since Cern HTTPD treats them as delimiters for
+# encoding times, so you get mismatches if you compress your files:
+# a.html.gz will map to a_b.html.gz
+def fixfunnychars(addr):
+    i = 0
+    while i < len(addr):
+        c = addr[i]
+        if c not in goodchars:
+            c = '-'
+            addr = addr[:i] + c + addr[i+1:]
+        i = i + len(c)
+    return addr
+
+
+# Increment a string used as an enumeration
+def increment(s):
+    if not s:
+        return '1'
+    for sequence in string.digits, string.ascii_lowercase, string.ascii_uppercase:
+        lastc = s[-1]
+        if lastc in sequence:
+            i = sequence.index(lastc) + 1
+            if i >= len(sequence):
+                if len(s) == 1:
+                    s = sequence[0]*2
+                    if s == '00':
+                        s = '10'
+                else:
+                    s = increment(s[:-1]) + sequence[0]
+            else:
+                s = s[:-1] + sequence[i]
+            return s
+    return s # Don't increment
+
+
+def test():
+    import sys
+    debugging = 0
+    print_headers = 0
+    cont = 0
+    html3 = 0
+    htmlhelp = ''
+
+    while sys.argv[1] == ['-d']:
+        debugging = debugging + 1
+        del sys.argv[1]
+    if sys.argv[1] == '-p':
+        print_headers = 1
+        del sys.argv[1]
+    if sys.argv[1] == '-c':
+        cont = 1
+        del sys.argv[1]
+    if sys.argv[1] == '-3':
+        html3 = 1
+        del sys.argv[1]
+    if sys.argv[1] == '-H':
+        helpbase = sys.argv[2]
+        del sys.argv[1:3]
+    if len(sys.argv) != 3:
+        print('usage: texi2hh [-d [-d]] [-p] [-c] [-3] [-H htmlhelp]', \
+              'inputfile outputdirectory')
+        sys.exit(2)
+
+    if html3:
+        parser = TexinfoParserHTML3()
+    else:
+        parser = TexinfoParser()
+    parser.cont = cont
+    parser.debugging = debugging
+    parser.print_headers = print_headers
+
+    file = sys.argv[1]
+    dirname  = sys.argv[2]
+    parser.setdirname(dirname)
+    parser.setincludedir(os.path.dirname(file))
+
+    htmlhelp = HTMLHelp(helpbase, dirname)
+    parser.sethtmlhelp(htmlhelp)
+
+    try:
+        fp = open(file, 'r')
+    except IOError as msg:
+        print(file, ':', msg)
+        sys.exit(1)
+
+    with fp:
+        parser.parse(fp)
+    parser.report()
+
+    htmlhelp.finalize()
+
+
+if __name__ == "__main__":
+    test()
diff --git a/marketing/Tools/scripts/untabify.py b/marketing/Tools/scripts/untabify.py
new file mode 100644
index 0000000000000000000000000000000000000000..861c83ced90f241e301fa45ab2febc39c41e7232
--- /dev/null
+++ b/marketing/Tools/scripts/untabify.py
@@ -0,0 +1,55 @@
+#! /usr/bin/env python3
+
+"Replace tabs with spaces in argument files.  Print names of changed files."
+
+import os
+import sys
+import getopt
+import tokenize
+
+def main():
+    tabsize = 8
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "t:")
+        if not args:
+            raise getopt.error("At least one file argument required")
+    except getopt.error as msg:
+        print(msg)
+        print("usage:", sys.argv[0], "[-t tabwidth] file ...")
+        return
+    for optname, optvalue in opts:
+        if optname == '-t':
+            tabsize = int(optvalue)
+
+    for filename in args:
+        process(filename, tabsize)
+
+
+def process(filename, tabsize, verbose=True):
+    try:
+        with tokenize.open(filename) as f:
+            text = f.read()
+            encoding = f.encoding
+    except IOError as msg:
+        print("%r: I/O error: %s" % (filename, msg))
+        return
+    newtext = text.expandtabs(tabsize)
+    if newtext == text:
+        return
+    backup = filename + "~"
+    try:
+        os.unlink(backup)
+    except OSError:
+        pass
+    try:
+        os.rename(filename, backup)
+    except OSError:
+        pass
+    with open(filename, "w", encoding=encoding) as f:
+        f.write(newtext)
+    if verbose:
+        print(filename)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/marketing/Tools/scripts/update_file.py b/marketing/Tools/scripts/update_file.py
new file mode 100644
index 0000000000000000000000000000000000000000..224585c69bbaeb6d3ed37278b5b9b3a56b2c2c4e
--- /dev/null
+++ b/marketing/Tools/scripts/update_file.py
@@ -0,0 +1,28 @@
+"""
+A script that replaces an old file with a new one, only if the contents
+actually changed.  If not, the new file is simply deleted.
+
+This avoids wholesale rebuilds when a code (re)generation phase does not
+actually change the in-tree generated code.
+"""
+
+import os
+import sys
+
+
+def main(old_path, new_path):
+    with open(old_path, 'rb') as f:
+        old_contents = f.read()
+    with open(new_path, 'rb') as f:
+        new_contents = f.read()
+    if old_contents != new_contents:
+        os.replace(new_path, old_path)
+    else:
+        os.unlink(new_path)
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 3:
+        print("Usage: %s  " % (sys.argv[0],))
+        sys.exit(1)
+    main(sys.argv[1], sys.argv[2])
diff --git a/marketing/Tools/scripts/var_access_benchmark.py b/marketing/Tools/scripts/var_access_benchmark.py
new file mode 100644
index 0000000000000000000000000000000000000000..03b712d304ffe9bcd2d41f25d8b1afe36661bf7b
--- /dev/null
+++ b/marketing/Tools/scripts/var_access_benchmark.py
@@ -0,0 +1,297 @@
+'Show relative speeds of local, nonlocal, global, and built-in access.'
+
+# Please leave this code so that it runs under older versions of
+# Python 3 (no f-strings).  That will allow benchmarking for
+# cross-version comparisons.  To run the benchmark on Python 2,
+# comment-out the nonlocal reads and writes.
+
+from collections import deque, namedtuple
+
+trials = [None] * 500
+steps_per_trial = 25
+
+class A(object):
+    def m(self):
+        pass
+
+class B(object):
+    __slots__ = 'x'
+    def __init__(self, x):
+        self.x = x
+
+class C(object):
+    def __init__(self, x):
+        self.x = x
+
+def read_local(trials=trials):
+    v_local = 1
+    for t in trials:
+        v_local;    v_local;    v_local;    v_local;    v_local
+        v_local;    v_local;    v_local;    v_local;    v_local
+        v_local;    v_local;    v_local;    v_local;    v_local
+        v_local;    v_local;    v_local;    v_local;    v_local
+        v_local;    v_local;    v_local;    v_local;    v_local
+
+def make_nonlocal_reader():
+    v_nonlocal = 1
+    def inner(trials=trials):
+        for t in trials:
+            v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal
+            v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal
+            v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal
+            v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal
+            v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal; v_nonlocal
+    inner.__name__ = 'read_nonlocal'
+    return inner
+
+read_nonlocal = make_nonlocal_reader()
+
+v_global = 1
+def read_global(trials=trials):
+    for t in trials:
+        v_global; v_global; v_global; v_global; v_global
+        v_global; v_global; v_global; v_global; v_global
+        v_global; v_global; v_global; v_global; v_global
+        v_global; v_global; v_global; v_global; v_global
+        v_global; v_global; v_global; v_global; v_global
+
+def read_builtin(trials=trials):
+    for t in trials:
+        oct; oct; oct; oct; oct
+        oct; oct; oct; oct; oct
+        oct; oct; oct; oct; oct
+        oct; oct; oct; oct; oct
+        oct; oct; oct; oct; oct
+
+def read_classvar_from_class(trials=trials, A=A):
+    A.x = 1
+    for t in trials:
+        A.x;    A.x;    A.x;    A.x;    A.x
+        A.x;    A.x;    A.x;    A.x;    A.x
+        A.x;    A.x;    A.x;    A.x;    A.x
+        A.x;    A.x;    A.x;    A.x;    A.x
+        A.x;    A.x;    A.x;    A.x;    A.x
+
+def read_classvar_from_instance(trials=trials, A=A):
+    A.x = 1
+    a = A()
+    for t in trials:
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+
+def read_instancevar(trials=trials, a=C(1)):
+    for t in trials:
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+
+def read_instancevar_slots(trials=trials, a=B(1)):
+    for t in trials:
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+
+def read_namedtuple(trials=trials, D=namedtuple('D', ['x'])):
+    a = D(1)
+    for t in trials:
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+        a.x;    a.x;    a.x;    a.x;    a.x
+
+def read_boundmethod(trials=trials, a=A()):
+    for t in trials:
+        a.m;    a.m;    a.m;    a.m;    a.m
+        a.m;    a.m;    a.m;    a.m;    a.m
+        a.m;    a.m;    a.m;    a.m;    a.m
+        a.m;    a.m;    a.m;    a.m;    a.m
+        a.m;    a.m;    a.m;    a.m;    a.m
+
+def write_local(trials=trials):
+    v_local = 1
+    for t in trials:
+        v_local = 1; v_local = 1; v_local = 1; v_local = 1; v_local = 1
+        v_local = 1; v_local = 1; v_local = 1; v_local = 1; v_local = 1
+        v_local = 1; v_local = 1; v_local = 1; v_local = 1; v_local = 1
+        v_local = 1; v_local = 1; v_local = 1; v_local = 1; v_local = 1
+        v_local = 1; v_local = 1; v_local = 1; v_local = 1; v_local = 1
+
+def make_nonlocal_writer():
+    v_nonlocal = 1
+    def inner(trials=trials):
+        nonlocal v_nonlocal
+        for t in trials:
+            v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1
+            v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1
+            v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1
+            v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1
+            v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1; v_nonlocal = 1
+    inner.__name__ = 'write_nonlocal'
+    return inner
+
+write_nonlocal = make_nonlocal_writer()
+
+def write_global(trials=trials):
+    global v_global
+    for t in trials:
+        v_global = 1; v_global = 1; v_global = 1; v_global = 1; v_global = 1
+        v_global = 1; v_global = 1; v_global = 1; v_global = 1; v_global = 1
+        v_global = 1; v_global = 1; v_global = 1; v_global = 1; v_global = 1
+        v_global = 1; v_global = 1; v_global = 1; v_global = 1; v_global = 1
+        v_global = 1; v_global = 1; v_global = 1; v_global = 1; v_global = 1
+
+def write_classvar(trials=trials, A=A):
+    for t in trials:
+        A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1
+        A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1
+        A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1
+        A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1
+        A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1;    A.x = 1
+
+def write_instancevar(trials=trials, a=C(1)):
+    for t in trials:
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+
+def write_instancevar_slots(trials=trials, a=B(1)):
+    for t in trials:
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+        a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1;    a.x = 1
+
+def read_list(trials=trials, a=[1]):
+    for t in trials:
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+
+def read_deque(trials=trials, a=deque([1])):
+    for t in trials:
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+
+def read_dict(trials=trials, a={0: 1}):
+    for t in trials:
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+        a[0];   a[0];   a[0];   a[0];   a[0]
+
+def read_strdict(trials=trials, a={'key': 1}):
+    for t in trials:
+        a['key'];   a['key'];   a['key'];   a['key'];   a['key']
+        a['key'];   a['key'];   a['key'];   a['key'];   a['key']
+        a['key'];   a['key'];   a['key'];   a['key'];   a['key']
+        a['key'];   a['key'];   a['key'];   a['key'];   a['key']
+        a['key'];   a['key'];   a['key'];   a['key'];   a['key']
+
+def list_append_pop(trials=trials, a=[1]):
+    ap, pop = a.append, a.pop
+    for t in trials:
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+
+def deque_append_pop(trials=trials, a=deque([1])):
+    ap, pop = a.append, a.pop
+    for t in trials:
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop()
+
+def deque_append_popleft(trials=trials, a=deque([1])):
+    ap, pop = a.append, a.popleft
+    for t in trials:
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop();
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop();
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop();
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop();
+        ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop(); ap(1); pop();
+
+def write_list(trials=trials, a=[1]):
+    for t in trials:
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+
+def write_deque(trials=trials, a=deque([1])):
+    for t in trials:
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+
+def write_dict(trials=trials, a={0: 1}):
+    for t in trials:
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+        a[0]=1; a[0]=1; a[0]=1; a[0]=1; a[0]=1
+
+def write_strdict(trials=trials, a={'key': 1}):
+    for t in trials:
+        a['key']=1; a['key']=1; a['key']=1; a['key']=1; a['key']=1
+        a['key']=1; a['key']=1; a['key']=1; a['key']=1; a['key']=1
+        a['key']=1; a['key']=1; a['key']=1; a['key']=1; a['key']=1
+        a['key']=1; a['key']=1; a['key']=1; a['key']=1; a['key']=1
+        a['key']=1; a['key']=1; a['key']=1; a['key']=1; a['key']=1
+
+def loop_overhead(trials=trials):
+    for t in trials:
+        pass
+
+
+if __name__=='__main__':
+
+    from timeit import Timer
+
+    for f in [
+            'Variable and attribute read access:',
+            read_local, read_nonlocal, read_global, read_builtin,
+            read_classvar_from_class, read_classvar_from_instance,
+            read_instancevar, read_instancevar_slots,
+            read_namedtuple, read_boundmethod,
+            '\nVariable and attribute write access:',
+            write_local, write_nonlocal, write_global,
+            write_classvar, write_instancevar, write_instancevar_slots,
+            '\nData structure read access:',
+            read_list, read_deque, read_dict, read_strdict,
+            '\nData structure write access:',
+            write_list, write_deque, write_dict, write_strdict,
+            '\nStack (or queue) operations:',
+            list_append_pop, deque_append_pop, deque_append_popleft,
+            '\nTiming loop overhead:',
+            loop_overhead]:
+        if isinstance(f, str):
+            print(f)
+            continue
+        timing = min(Timer(f).repeat(7, 1000))
+        timing *= 1000000 / (len(trials) * steps_per_trial)
+        print('{:6.1f} ns\t{}'.format(timing, f.__name__))
diff --git a/marketing/Tools/scripts/verify_ensurepip_wheels.py b/marketing/Tools/scripts/verify_ensurepip_wheels.py
new file mode 100644
index 0000000000000000000000000000000000000000..434a0b4c5387d4e7ae989b18f80e183bb8c43623
--- /dev/null
+++ b/marketing/Tools/scripts/verify_ensurepip_wheels.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+
+"""
+Compare checksums for wheels in :mod:`ensurepip` against the Cheeseshop.
+
+When GitHub Actions executes the script, output is formatted accordingly.
+https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#setting-a-notice-message
+"""
+
+import hashlib
+import json
+import os
+import re
+from pathlib import Path
+from urllib.request import urlopen
+
+PACKAGE_NAMES = ("pip", "setuptools")
+ENSURE_PIP_ROOT = Path(__file__).parent.parent.parent / "Lib/ensurepip"
+WHEEL_DIR = ENSURE_PIP_ROOT / "_bundled"
+ENSURE_PIP_INIT_PY_TEXT = (ENSURE_PIP_ROOT / "__init__.py").read_text(encoding="utf-8")
+GITHUB_ACTIONS = os.getenv("GITHUB_ACTIONS") == "true"
+
+
+def print_notice(file_path: str, message: str) -> None:
+    if GITHUB_ACTIONS:
+        message = f"::notice file={file_path}::{message}"
+    print(message, end="\n\n")
+
+
+def print_error(file_path: str, message: str) -> None:
+    if GITHUB_ACTIONS:
+        message = f"::error file={file_path}::{message}"
+    print(message, end="\n\n")
+
+
+def verify_wheel(package_name: str) -> bool:
+    # Find the package on disk
+    package_paths = list(WHEEL_DIR.glob(f"{package_name}*.whl"))
+    if len(package_paths) != 1:
+        if package_paths:
+            for p in package_paths:
+                print_error(p, f"Found more than one wheel for package {package_name}.")
+        else:
+            print_error("", f"Could not find a {package_name} wheel on disk.")
+        return False
+
+    package_path = package_paths[0]
+
+    print(f"Verifying checksum for {package_path}.")
+
+    # Find the version of the package used by ensurepip
+    package_version_match = re.search(
+        f'_{package_name.upper()}_VERSION = "([^"]+)', ENSURE_PIP_INIT_PY_TEXT
+    )
+    if not package_version_match:
+        print_error(
+            package_path,
+            f"No {package_name} version found in Lib/ensurepip/__init__.py.",
+        )
+        return False
+    package_version = package_version_match[1]
+
+    # Get the SHA 256 digest from the Cheeseshop
+    try:
+        raw_text = urlopen(f"https://pypi.org/pypi/{package_name}/json").read()
+    except (OSError, ValueError):
+        print_error(package_path, f"Could not fetch JSON metadata for {package_name}.")
+        return False
+
+    release_files = json.loads(raw_text)["releases"][package_version]
+    for release_info in release_files:
+        if package_path.name != release_info["filename"]:
+            continue
+        expected_digest = release_info["digests"].get("sha256", "")
+        break
+    else:
+        print_error(package_path, f"No digest for {package_name} found from PyPI.")
+        return False
+
+    # Compute the SHA 256 digest of the wheel on disk
+    actual_digest = hashlib.sha256(package_path.read_bytes()).hexdigest()
+
+    print(f"Expected digest: {expected_digest}")
+    print(f"Actual digest:   {actual_digest}")
+
+    if actual_digest != expected_digest:
+        print_error(
+            package_path, f"Failed to verify the checksum of the {package_name} wheel."
+        )
+        return False
+
+    print_notice(
+        package_path,
+        f"Successfully verified the checksum of the {package_name} wheel.",
+    )
+    return True
+
+
+if __name__ == "__main__":
+    exit_status = 0
+    for package_name in PACKAGE_NAMES:
+        if not verify_wheel(package_name):
+            exit_status = 1
+    raise SystemExit(exit_status)
diff --git a/marketing/Tools/scripts/which.py b/marketing/Tools/scripts/which.py
new file mode 100644
index 0000000000000000000000000000000000000000..b42e07c74ecac838f9bdcea088fb680e962aac1a
--- /dev/null
+++ b/marketing/Tools/scripts/which.py
@@ -0,0 +1,61 @@
+#! /usr/bin/env python3
+
+# Variant of "which".
+# On stderr, near and total misses are reported.
+# '-l' argument adds ls -l of each file found.
+
+import sys
+if sys.path[0] in (".", ""): del sys.path[0]
+
+import sys, os
+from stat import *
+
+def msg(str):
+    sys.stderr.write(str + '\n')
+
+def main():
+    pathlist = os.environ['PATH'].split(os.pathsep)
+
+    sts = 0
+    longlist = ''
+
+    if sys.argv[1:] and sys.argv[1][:2] == '-l':
+        longlist = sys.argv[1]
+        del sys.argv[1]
+
+    for prog in sys.argv[1:]:
+        ident = ()
+        for dir in pathlist:
+            filename = os.path.join(dir, prog)
+            try:
+                st = os.stat(filename)
+            except OSError:
+                continue
+            if not S_ISREG(st[ST_MODE]):
+                msg(filename + ': not a disk file')
+            else:
+                mode = S_IMODE(st[ST_MODE])
+                if mode & 0o111:
+                    if not ident:
+                        print(filename)
+                        ident = st[:3]
+                    else:
+                        if st[:3] == ident:
+                            s = 'same as: '
+                        else:
+                            s = 'also: '
+                        msg(s + filename)
+                else:
+                    msg(filename + ': not executable')
+            if longlist:
+                sts = os.system('ls ' + longlist + ' ' + filename)
+                sts = os.waitstatus_to_exitcode(sts)
+                if sts: msg('"ls -l" exit status: ' + repr(sts))
+        if not ident:
+            msg(prog + ': not found')
+            sts = 1
+
+    sys.exit(sts)
+
+if __name__ == '__main__':
+    main()
diff --git a/marketing/Tools/scripts/win_add2path.py b/marketing/Tools/scripts/win_add2path.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c9aedc5ed8dcaeebb88fd895f95c6058bd7f51f
--- /dev/null
+++ b/marketing/Tools/scripts/win_add2path.py
@@ -0,0 +1,58 @@
+"""Add Python to the search path on Windows
+
+This is a simple script to add Python to the Windows search path. It
+modifies the current user (HKCU) tree of the registry.
+
+Copyright (c) 2008 by Christian Heimes 
+Licensed to PSF under a Contributor Agreement.
+"""
+
+import sys
+import site
+import os
+import winreg
+
+HKCU = winreg.HKEY_CURRENT_USER
+ENV = "Environment"
+PATH = "PATH"
+DEFAULT = "%PATH%"
+
+def modify():
+    pythonpath = os.path.dirname(os.path.normpath(sys.executable))
+    scripts = os.path.join(pythonpath, "Scripts")
+    appdata = os.environ["APPDATA"]
+    if hasattr(site, "USER_SITE"):
+        usersite = site.USER_SITE.replace(appdata, "%APPDATA%")
+        userpath = os.path.dirname(usersite)
+        userscripts = os.path.join(userpath, "Scripts")
+    else:
+        userscripts = None
+
+    with winreg.CreateKey(HKCU, ENV) as key:
+        try:
+            envpath = winreg.QueryValueEx(key, PATH)[0]
+        except OSError:
+            envpath = DEFAULT
+
+        paths = [envpath]
+        for path in (pythonpath, scripts, userscripts):
+            if path and path not in envpath and os.path.isdir(path):
+                paths.append(path)
+
+        envpath = os.pathsep.join(paths)
+        winreg.SetValueEx(key, PATH, 0, winreg.REG_EXPAND_SZ, envpath)
+        return paths, envpath
+
+def main():
+    paths, envpath = modify()
+    if len(paths) > 1:
+        print("Path(s) added:")
+        print('\n'.join(paths[1:]))
+    else:
+        print("No path was added")
+    print("\nPATH is now:\n%s\n" % envpath)
+    print("Expanded:")
+    print(winreg.ExpandEnvironmentStrings(envpath))
+
+if __name__ == '__main__':
+    main()
diff --git a/marketing/api-ms-win-core-console-l1-1-0.dll b/marketing/api-ms-win-core-console-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..acd04c62fdd8e526abdfdf65ea492553c3664f3f
Binary files /dev/null and b/marketing/api-ms-win-core-console-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-console-l1-2-0.dll b/marketing/api-ms-win-core-console-l1-2-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..d16a2cc4deae8081151ebb1a29f87b73826e5b82
Binary files /dev/null and b/marketing/api-ms-win-core-console-l1-2-0.dll differ
diff --git a/marketing/api-ms-win-core-datetime-l1-1-0.dll b/marketing/api-ms-win-core-datetime-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..074cfe94399d568bb1422fa7ac3def357dcab680
Binary files /dev/null and b/marketing/api-ms-win-core-datetime-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-debug-l1-1-0.dll b/marketing/api-ms-win-core-debug-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..7d7629f0f9a1b68f592041c1dc7479dda2d1aded
Binary files /dev/null and b/marketing/api-ms-win-core-debug-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-errorhandling-l1-1-0.dll b/marketing/api-ms-win-core-errorhandling-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..bb02242b3347dce2608222199b11f2a94151ba10
Binary files /dev/null and b/marketing/api-ms-win-core-errorhandling-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-fibers-l1-1-0.dll b/marketing/api-ms-win-core-fibers-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..021b57b8ca66cced0f6528479701b5fd20187579
Binary files /dev/null and b/marketing/api-ms-win-core-fibers-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-file-l1-1-0.dll b/marketing/api-ms-win-core-file-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..443200ccc30bbe4e120e9a6b993d58582b3991ea
Binary files /dev/null and b/marketing/api-ms-win-core-file-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-file-l1-2-0.dll b/marketing/api-ms-win-core-file-l1-2-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..97a0097ae6a2f8ec3d35c4f3271912a8860d75f5
Binary files /dev/null and b/marketing/api-ms-win-core-file-l1-2-0.dll differ
diff --git a/marketing/api-ms-win-core-file-l2-1-0.dll b/marketing/api-ms-win-core-file-l2-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..97c4da274470272e3dd9d1499027bef85e7fb40e
Binary files /dev/null and b/marketing/api-ms-win-core-file-l2-1-0.dll differ
diff --git a/marketing/api-ms-win-core-handle-l1-1-0.dll b/marketing/api-ms-win-core-handle-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..825650c4331c468920d36b32aed8955327de5f29
Binary files /dev/null and b/marketing/api-ms-win-core-handle-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-heap-l1-1-0.dll b/marketing/api-ms-win-core-heap-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..61f6db95416d433d34c061c6fc9d3a98ffc57b89
Binary files /dev/null and b/marketing/api-ms-win-core-heap-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-interlocked-l1-1-0.dll b/marketing/api-ms-win-core-interlocked-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..e8b1f813d512d0818f2b67ddf21582b2a33ed881
Binary files /dev/null and b/marketing/api-ms-win-core-interlocked-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-libraryloader-l1-1-0.dll b/marketing/api-ms-win-core-libraryloader-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..c895394c2abcf3ed6b9c72699a46c809ceef7698
Binary files /dev/null and b/marketing/api-ms-win-core-libraryloader-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-localization-l1-2-0.dll b/marketing/api-ms-win-core-localization-l1-2-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..6a8cdf3e31978cfb521bd82fb5e6fd3313dba4c1
Binary files /dev/null and b/marketing/api-ms-win-core-localization-l1-2-0.dll differ
diff --git a/marketing/api-ms-win-core-memory-l1-1-0.dll b/marketing/api-ms-win-core-memory-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..4f084c2de4687d4bcee0cdcf826fab5585ccc1f3
Binary files /dev/null and b/marketing/api-ms-win-core-memory-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-namedpipe-l1-1-0.dll b/marketing/api-ms-win-core-namedpipe-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..8657870cff89d2e5789ff937f96ad9af8865dcda
Binary files /dev/null and b/marketing/api-ms-win-core-namedpipe-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-processenvironment-l1-1-0.dll b/marketing/api-ms-win-core-processenvironment-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..8cb14919f180e146f1b59302d3fd20f4c627a027
Binary files /dev/null and b/marketing/api-ms-win-core-processenvironment-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-processthreads-l1-1-0.dll b/marketing/api-ms-win-core-processthreads-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..83ffbbfc126f2009d7c4a5fff8c24f0db0d3f498
Binary files /dev/null and b/marketing/api-ms-win-core-processthreads-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-processthreads-l1-1-1.dll b/marketing/api-ms-win-core-processthreads-l1-1-1.dll
new file mode 100644
index 0000000000000000000000000000000000000000..f129357cd90788aa47661a8e62b425a94ab8aa28
Binary files /dev/null and b/marketing/api-ms-win-core-processthreads-l1-1-1.dll differ
diff --git a/marketing/api-ms-win-core-profile-l1-1-0.dll b/marketing/api-ms-win-core-profile-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..2f74dc209b550423b61cc2e2dd221c2ff6861703
Binary files /dev/null and b/marketing/api-ms-win-core-profile-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-rtlsupport-l1-1-0.dll b/marketing/api-ms-win-core-rtlsupport-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..ceb4c0d85b83a27950585296bf1d558715a6b559
Binary files /dev/null and b/marketing/api-ms-win-core-rtlsupport-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-string-l1-1-0.dll b/marketing/api-ms-win-core-string-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..5a6eca6a202606803e93acd30e1328665e8c5621
Binary files /dev/null and b/marketing/api-ms-win-core-string-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-synch-l1-1-0.dll b/marketing/api-ms-win-core-synch-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..fcab465b88f6df5a8fdc988e6bb89324c1e6739c
Binary files /dev/null and b/marketing/api-ms-win-core-synch-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-synch-l1-2-0.dll b/marketing/api-ms-win-core-synch-l1-2-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..44d4ea07bef044fa469c88d1b42d0e24bd6fd284
Binary files /dev/null and b/marketing/api-ms-win-core-synch-l1-2-0.dll differ
diff --git a/marketing/api-ms-win-core-sysinfo-l1-1-0.dll b/marketing/api-ms-win-core-sysinfo-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..1ac01dd82a3d91a1077e379e47bae3c600148656
Binary files /dev/null and b/marketing/api-ms-win-core-sysinfo-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-timezone-l1-1-0.dll b/marketing/api-ms-win-core-timezone-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..944bada4cc2355b1cfe09b5611435b0eafddacf8
Binary files /dev/null and b/marketing/api-ms-win-core-timezone-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-core-util-l1-1-0.dll b/marketing/api-ms-win-core-util-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..41b1019c846dc1fdb4034cda459b630d8dfe1551
Binary files /dev/null and b/marketing/api-ms-win-core-util-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-conio-l1-1-0.dll b/marketing/api-ms-win-crt-conio-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..c45f2e59b99daa37cb9d2b2da67dd168f0ca8512
Binary files /dev/null and b/marketing/api-ms-win-crt-conio-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-convert-l1-1-0.dll b/marketing/api-ms-win-crt-convert-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..d26ff06d0207ea81b21262e351d341e9e5b36b56
Binary files /dev/null and b/marketing/api-ms-win-crt-convert-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-environment-l1-1-0.dll b/marketing/api-ms-win-crt-environment-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..814effa790da9d8aba7e15073ffab9624a758d5c
Binary files /dev/null and b/marketing/api-ms-win-crt-environment-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-filesystem-l1-1-0.dll b/marketing/api-ms-win-crt-filesystem-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..94bd00b4556f3f4779a016fe6fad8ff8f4ac02c9
Binary files /dev/null and b/marketing/api-ms-win-crt-filesystem-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-heap-l1-1-0.dll b/marketing/api-ms-win-crt-heap-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..afe8a06ae72ff7ca8b21d28e246a625650b05438
Binary files /dev/null and b/marketing/api-ms-win-crt-heap-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-locale-l1-1-0.dll b/marketing/api-ms-win-crt-locale-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..4c078b3254a505a8e8cfa1fe121bfece89e036bc
Binary files /dev/null and b/marketing/api-ms-win-crt-locale-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-math-l1-1-0.dll b/marketing/api-ms-win-crt-math-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..240b35e356929417567ab4789bdec8a2b3e9be35
Binary files /dev/null and b/marketing/api-ms-win-crt-math-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-multibyte-l1-1-0.dll b/marketing/api-ms-win-crt-multibyte-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..f7deb09c8452a9490a5e8bee5e10cd67781ef0f6
Binary files /dev/null and b/marketing/api-ms-win-crt-multibyte-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-private-l1-1-0.dll b/marketing/api-ms-win-crt-private-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..b9af7f18f20ec4be73f5d76c783378fd017bb659
Binary files /dev/null and b/marketing/api-ms-win-crt-private-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-process-l1-1-0.dll b/marketing/api-ms-win-crt-process-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..3325b2368f0efbf850678daaf0653384c7030b90
Binary files /dev/null and b/marketing/api-ms-win-crt-process-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-runtime-l1-1-0.dll b/marketing/api-ms-win-crt-runtime-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..b5b1abd6003a4581bec90d2d8f24b8ec3c4f1916
Binary files /dev/null and b/marketing/api-ms-win-crt-runtime-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-stdio-l1-1-0.dll b/marketing/api-ms-win-crt-stdio-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..8dc9e221cb90aab1d026097eb8895438d965c715
Binary files /dev/null and b/marketing/api-ms-win-crt-stdio-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-string-l1-1-0.dll b/marketing/api-ms-win-crt-string-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..6ba75fe6a4b32851201e14d8d815020ca9981f65
Binary files /dev/null and b/marketing/api-ms-win-crt-string-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-time-l1-1-0.dll b/marketing/api-ms-win-crt-time-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..94884532f2c8b05d601007319936854df53afdd5
Binary files /dev/null and b/marketing/api-ms-win-crt-time-l1-1-0.dll differ
diff --git a/marketing/api-ms-win-crt-utility-l1-1-0.dll b/marketing/api-ms-win-crt-utility-l1-1-0.dll
new file mode 100644
index 0000000000000000000000000000000000000000..07f203b7881e760a7e490685c19b76a4690e937c
Binary files /dev/null and b/marketing/api-ms-win-crt-utility-l1-1-0.dll differ
diff --git a/marketing/conda-meta/ca-certificates-2025.2.25-haa95532_0.json b/marketing/conda-meta/ca-certificates-2025.2.25-haa95532_0.json
new file mode 100644
index 0000000000000000000000000000000000000000..ad2800f0852fc82ee88b7b6c4d945210e2e95be1
--- /dev/null
+++ b/marketing/conda-meta/ca-certificates-2025.2.25-haa95532_0.json
@@ -0,0 +1,52 @@
+{
+  "build": "haa95532_0",
+  "build_number": 0,
+  "channel": "https://repo.anaconda.com/pkgs/main/win-64",
+  "constrains": [],
+  "depends": [],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\ca-certificates-2025.2.25-haa95532_0",
+  "features": "",
+  "files": [
+    "Library/ssl/cacert.pem",
+    "Library/ssl/cert.pem",
+    ".nonadmin"
+  ],
+  "fn": "ca-certificates-2025.2.25-haa95532_0.conda",
+  "legacy_bz2_md5": "e3b5a74405c1f5f34df64c1263147d0b",
+  "license": "MPL-2.0",
+  "license_family": "Other",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\ca-certificates-2025.2.25-haa95532_0",
+    "type": 1
+  },
+  "md5": "808dfb694164c6394052c42c02f04514",
+  "name": "ca-certificates",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\ca-certificates-2025.2.25-haa95532_0.conda",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "Library/ssl/cacert.pem",
+        "path_type": "hardlink",
+        "sha256": "50a6277ec69113f00c5fd45f09e8b97a4b3e32daa35d3a95ab30137a55386cef",
+        "sha256_in_prefix": "50a6277ec69113f00c5fd45f09e8b97a4b3e32daa35d3a95ab30137a55386cef",
+        "size_in_bytes": 233263
+      },
+      {
+        "_path": "Library/ssl/cert.pem",
+        "path_type": "hardlink",
+        "sha256": "50a6277ec69113f00c5fd45f09e8b97a4b3e32daa35d3a95ab30137a55386cef",
+        "sha256_in_prefix": "50a6277ec69113f00c5fd45f09e8b97a4b3e32daa35d3a95ab30137a55386cef",
+        "size_in_bytes": 233263
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "bfaac6331ef8c28b3c46cbb3fa27df52a0f5101e1a58474e3771c4183c44816e",
+  "size": 133559,
+  "subdir": "win-64",
+  "timestamp": 1740582512824,
+  "track_features": "",
+  "url": "https://repo.anaconda.com/pkgs/main/win-64/ca-certificates-2025.2.25-haa95532_0.conda",
+  "version": "2025.2.25"
+}
\ No newline at end of file
diff --git a/marketing/conda-meta/history b/marketing/conda-meta/history
new file mode 100644
index 0000000000000000000000000000000000000000..da4129b45fcc04e77a42d95dec02e9b75eb400cd
--- /dev/null
+++ b/marketing/conda-meta/history
@@ -0,0 +1,14 @@
+==> 2025-03-27 23:35:26 <==
+# cmd: C:\Users\mustafa.tark\Anaconda3\Scripts\conda-script.py create -p ./marketing python=3.9 -y
+# conda version: 22.9.0
++defaults/noarch::tzdata-2025a-h04d1e81_0
++defaults/win-64::ca-certificates-2025.2.25-haa95532_0
++defaults/win-64::openssl-3.0.16-h3f729d1_0
++defaults/win-64::pip-25.0-py39haa95532_0
++defaults/win-64::python-3.9.21-h8205438_1
++defaults/win-64::setuptools-75.8.0-py39haa95532_0
++defaults/win-64::sqlite-3.45.3-h2bbff1b_0
++defaults/win-64::vc-14.42-haa95532_4
++defaults/win-64::vs2015_runtime-14.42.34433-he0abc0d_4
++defaults/win-64::wheel-0.45.1-py39haa95532_0
+# update specs: ['python=3.9']
diff --git a/marketing/conda-meta/openssl-3.0.16-h3f729d1_0.json b/marketing/conda-meta/openssl-3.0.16-h3f729d1_0.json
new file mode 100644
index 0000000000000000000000000000000000000000..70d21c156415eb801a82080f695a57899f34c211
--- /dev/null
+++ b/marketing/conda-meta/openssl-3.0.16-h3f729d1_0.json
@@ -0,0 +1,1352 @@
+{
+  "build": "h3f729d1_0",
+  "build_number": 0,
+  "channel": "https://repo.anaconda.com/pkgs/main/win-64",
+  "constrains": [],
+  "depends": [
+    "ca-certificates",
+    "vc >=14.2,<15.0a0",
+    "vs2015_runtime >=14.29.30133,<15.0a0"
+  ],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\openssl-3.0.16-h3f729d1_0",
+  "features": "",
+  "files": [
+    "Library/bin/c_rehash.pl",
+    "Library/bin/libcrypto-3-x64.dll",
+    "Library/bin/libcrypto-3-x64.pdb",
+    "Library/bin/libssl-3-x64.dll",
+    "Library/bin/libssl-3-x64.pdb",
+    "Library/bin/openssl.exe",
+    "Library/bin/openssl.pdb",
+    "Library/include/openssl/__DECC_INCLUDE_EPILOGUE.H",
+    "Library/include/openssl/__DECC_INCLUDE_PROLOGUE.H",
+    "Library/include/openssl/aes.h",
+    "Library/include/openssl/applink.c",
+    "Library/include/openssl/asn1.h",
+    "Library/include/openssl/asn1_mac.h",
+    "Library/include/openssl/asn1err.h",
+    "Library/include/openssl/asn1t.h",
+    "Library/include/openssl/async.h",
+    "Library/include/openssl/asyncerr.h",
+    "Library/include/openssl/bio.h",
+    "Library/include/openssl/bioerr.h",
+    "Library/include/openssl/blowfish.h",
+    "Library/include/openssl/bn.h",
+    "Library/include/openssl/bnerr.h",
+    "Library/include/openssl/buffer.h",
+    "Library/include/openssl/buffererr.h",
+    "Library/include/openssl/camellia.h",
+    "Library/include/openssl/cast.h",
+    "Library/include/openssl/cmac.h",
+    "Library/include/openssl/cmp.h",
+    "Library/include/openssl/cmp_util.h",
+    "Library/include/openssl/cmperr.h",
+    "Library/include/openssl/cms.h",
+    "Library/include/openssl/cmserr.h",
+    "Library/include/openssl/comp.h",
+    "Library/include/openssl/comperr.h",
+    "Library/include/openssl/conf.h",
+    "Library/include/openssl/conf_api.h",
+    "Library/include/openssl/conferr.h",
+    "Library/include/openssl/configuration.h",
+    "Library/include/openssl/conftypes.h",
+    "Library/include/openssl/core.h",
+    "Library/include/openssl/core_dispatch.h",
+    "Library/include/openssl/core_names.h",
+    "Library/include/openssl/core_object.h",
+    "Library/include/openssl/crmf.h",
+    "Library/include/openssl/crmferr.h",
+    "Library/include/openssl/crypto.h",
+    "Library/include/openssl/cryptoerr.h",
+    "Library/include/openssl/cryptoerr_legacy.h",
+    "Library/include/openssl/ct.h",
+    "Library/include/openssl/cterr.h",
+    "Library/include/openssl/decoder.h",
+    "Library/include/openssl/decodererr.h",
+    "Library/include/openssl/des.h",
+    "Library/include/openssl/dh.h",
+    "Library/include/openssl/dherr.h",
+    "Library/include/openssl/dsa.h",
+    "Library/include/openssl/dsaerr.h",
+    "Library/include/openssl/dtls1.h",
+    "Library/include/openssl/e_os2.h",
+    "Library/include/openssl/ebcdic.h",
+    "Library/include/openssl/ec.h",
+    "Library/include/openssl/ecdh.h",
+    "Library/include/openssl/ecdsa.h",
+    "Library/include/openssl/ecerr.h",
+    "Library/include/openssl/encoder.h",
+    "Library/include/openssl/encodererr.h",
+    "Library/include/openssl/engine.h",
+    "Library/include/openssl/engineerr.h",
+    "Library/include/openssl/err.h",
+    "Library/include/openssl/ess.h",
+    "Library/include/openssl/esserr.h",
+    "Library/include/openssl/evp.h",
+    "Library/include/openssl/evperr.h",
+    "Library/include/openssl/fips_names.h",
+    "Library/include/openssl/fipskey.h",
+    "Library/include/openssl/hmac.h",
+    "Library/include/openssl/http.h",
+    "Library/include/openssl/httperr.h",
+    "Library/include/openssl/idea.h",
+    "Library/include/openssl/kdf.h",
+    "Library/include/openssl/kdferr.h",
+    "Library/include/openssl/lhash.h",
+    "Library/include/openssl/macros.h",
+    "Library/include/openssl/md2.h",
+    "Library/include/openssl/md4.h",
+    "Library/include/openssl/md5.h",
+    "Library/include/openssl/mdc2.h",
+    "Library/include/openssl/modes.h",
+    "Library/include/openssl/obj_mac.h",
+    "Library/include/openssl/objects.h",
+    "Library/include/openssl/objectserr.h",
+    "Library/include/openssl/ocsp.h",
+    "Library/include/openssl/ocsperr.h",
+    "Library/include/openssl/opensslconf.h",
+    "Library/include/openssl/opensslv.h",
+    "Library/include/openssl/ossl_typ.h",
+    "Library/include/openssl/param_build.h",
+    "Library/include/openssl/params.h",
+    "Library/include/openssl/pem.h",
+    "Library/include/openssl/pem2.h",
+    "Library/include/openssl/pemerr.h",
+    "Library/include/openssl/pkcs12.h",
+    "Library/include/openssl/pkcs12err.h",
+    "Library/include/openssl/pkcs7.h",
+    "Library/include/openssl/pkcs7err.h",
+    "Library/include/openssl/prov_ssl.h",
+    "Library/include/openssl/proverr.h",
+    "Library/include/openssl/provider.h",
+    "Library/include/openssl/rand.h",
+    "Library/include/openssl/randerr.h",
+    "Library/include/openssl/rc2.h",
+    "Library/include/openssl/rc4.h",
+    "Library/include/openssl/rc5.h",
+    "Library/include/openssl/ripemd.h",
+    "Library/include/openssl/rsa.h",
+    "Library/include/openssl/rsaerr.h",
+    "Library/include/openssl/safestack.h",
+    "Library/include/openssl/seed.h",
+    "Library/include/openssl/self_test.h",
+    "Library/include/openssl/sha.h",
+    "Library/include/openssl/srp.h",
+    "Library/include/openssl/srtp.h",
+    "Library/include/openssl/ssl.h",
+    "Library/include/openssl/ssl2.h",
+    "Library/include/openssl/ssl3.h",
+    "Library/include/openssl/sslerr.h",
+    "Library/include/openssl/sslerr_legacy.h",
+    "Library/include/openssl/stack.h",
+    "Library/include/openssl/store.h",
+    "Library/include/openssl/storeerr.h",
+    "Library/include/openssl/symhacks.h",
+    "Library/include/openssl/tls1.h",
+    "Library/include/openssl/trace.h",
+    "Library/include/openssl/ts.h",
+    "Library/include/openssl/tserr.h",
+    "Library/include/openssl/txt_db.h",
+    "Library/include/openssl/types.h",
+    "Library/include/openssl/ui.h",
+    "Library/include/openssl/uierr.h",
+    "Library/include/openssl/whrlpool.h",
+    "Library/include/openssl/x509.h",
+    "Library/include/openssl/x509_vfy.h",
+    "Library/include/openssl/x509err.h",
+    "Library/include/openssl/x509v3.h",
+    "Library/include/openssl/x509v3err.h",
+    "Library/lib/libcrypto.lib",
+    "Library/lib/libssl.lib",
+    "Library/lib/pkgconfig/libcrypto.pc",
+    "Library/lib/pkgconfig/libssl.pc",
+    "Library/lib/pkgconfig/openssl.pc",
+    "Library/ssl/ct_log_list.cnf",
+    "Library/ssl/ct_log_list.cnf.dist",
+    "Library/ssl/misc/CA.pl",
+    "Library/ssl/misc/tsget.pl",
+    "Library/ssl/openssl.cnf",
+    "Library/ssl/openssl.cnf.dist",
+    "etc/conda/activate.d/openssl_activate.bat",
+    "etc/conda/activate.d/openssl_activate.ps1",
+    "etc/conda/activate.d/openssl_activate.sh",
+    "etc/conda/deactivate.d/openssl_deactivate.bat",
+    "etc/conda/deactivate.d/openssl_deactivate.ps1",
+    "etc/conda/deactivate.d/openssl_deactivate.sh",
+    ".nonadmin"
+  ],
+  "fn": "openssl-3.0.16-h3f729d1_0.conda",
+  "legacy_bz2_md5": "e071cd2b74e888dd3aef739ee4060bc0",
+  "license": "Apache-2.0",
+  "license_family": "Apache",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\openssl-3.0.16-h3f729d1_0",
+    "type": 1
+  },
+  "md5": "5ceb57e424ffe9918ba8f8af4fcc936a",
+  "name": "openssl",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\openssl-3.0.16-h3f729d1_0.conda",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "Library/bin/c_rehash.pl",
+        "file_mode": "text",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:\\\\b\\\\abs_04f5aioy9i\\\\croot\\\\openssl_1740989503961\\\\_h_env",
+        "sha256": "3b8fa93ef1ce2bac0fc65f2e1c8d8bb5cbaee2751848ac619f33ae95d1ca7c95",
+        "sha256_in_prefix": "efdd025520d7ddd4c3e0ad590eb6863b48b5f569d964547a0c1e5a77c0014447",
+        "size_in_bytes": 7268
+      },
+      {
+        "_path": "Library/bin/libcrypto-3-x64.dll",
+        "file_mode": "binary",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:\\b\\abs_04f5aioy9i\\croot\\openssl_1740989503961\\_h_env",
+        "sha256": "97ebc121e9478d09358acf8d8c68b465eaa99f8ee3cd515b3d440525b6a9ce90",
+        "sha256_in_prefix": "97ebc121e9478d09358acf8d8c68b465eaa99f8ee3cd515b3d440525b6a9ce90",
+        "size_in_bytes": 5297424
+      },
+      {
+        "_path": "Library/bin/libcrypto-3-x64.pdb",
+        "file_mode": "binary",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:\\\\b\\\\abs_04f5aioy9i\\\\croot\\\\openssl_1740989503961\\\\_h_env",
+        "sha256": "09b5836c5d53c4b002679267f11be07782cc2074101c0caa5d8e8d902d5004b5",
+        "sha256_in_prefix": "09b5836c5d53c4b002679267f11be07782cc2074101c0caa5d8e8d902d5004b5",
+        "size_in_bytes": 16076800
+      },
+      {
+        "_path": "Library/bin/libssl-3-x64.dll",
+        "path_type": "hardlink",
+        "sha256": "d6011e2c3ed87a37dbd7454ef84cd4679e79644a103b74087ca01eccf52c54a8",
+        "sha256_in_prefix": "d6011e2c3ed87a37dbd7454ef84cd4679e79644a103b74087ca01eccf52c54a8",
+        "size_in_bytes": 790288
+      },
+      {
+        "_path": "Library/bin/libssl-3-x64.pdb",
+        "file_mode": "binary",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:\\\\b\\\\abs_04f5aioy9i\\\\croot\\\\openssl_1740989503961\\\\_h_env",
+        "sha256": "f9739c5f68dea779c99b8248c37a311eb57477e5786389f7e2b9574b5a4c5d09",
+        "sha256_in_prefix": "f9739c5f68dea779c99b8248c37a311eb57477e5786389f7e2b9574b5a4c5d09",
+        "size_in_bytes": 2895872
+      },
+      {
+        "_path": "Library/bin/openssl.exe",
+        "path_type": "hardlink",
+        "sha256": "4b3f7f194445efc4bac827860842106aed656d6507527482bffd4faa321a2931",
+        "sha256_in_prefix": "4b3f7f194445efc4bac827860842106aed656d6507527482bffd4faa321a2931",
+        "size_in_bytes": 735504
+      },
+      {
+        "_path": "Library/bin/openssl.pdb",
+        "file_mode": "binary",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:\\\\b\\\\abs_04f5aioy9i\\\\croot\\\\openssl_1740989503961\\\\_h_env",
+        "sha256": "f9978c3a12de8ae47b34c565dd4a6d99e886dba69251810e1581f2ac4155842c",
+        "sha256_in_prefix": "f9978c3a12de8ae47b34c565dd4a6d99e886dba69251810e1581f2ac4155842c",
+        "size_in_bytes": 3084288
+      },
+      {
+        "_path": "Library/include/openssl/__DECC_INCLUDE_EPILOGUE.H",
+        "path_type": "hardlink",
+        "sha256": "3d837d015f23ad248d7e0c74b5b8ca102d81525f166a0a4b7c19900eea982644",
+        "sha256_in_prefix": "3d837d015f23ad248d7e0c74b5b8ca102d81525f166a0a4b7c19900eea982644",
+        "size_in_bytes": 729
+      },
+      {
+        "_path": "Library/include/openssl/__DECC_INCLUDE_PROLOGUE.H",
+        "path_type": "hardlink",
+        "sha256": "e66be3418a7b707f09fa011c85b0b3fdfcfa1740c46da11385abf23fe9983529",
+        "sha256_in_prefix": "e66be3418a7b707f09fa011c85b0b3fdfcfa1740c46da11385abf23fe9983529",
+        "size_in_bytes": 801
+      },
+      {
+        "_path": "Library/include/openssl/aes.h",
+        "path_type": "hardlink",
+        "sha256": "27aaa89367b022b12b66cf52c3c2d68f6761965ac36f3f1153202fa44692ad0e",
+        "sha256_in_prefix": "27aaa89367b022b12b66cf52c3c2d68f6761965ac36f3f1153202fa44692ad0e",
+        "size_in_bytes": 3752
+      },
+      {
+        "_path": "Library/include/openssl/applink.c",
+        "path_type": "hardlink",
+        "sha256": "64f2bbf22447c293a26c309459ac6ed5a77912c2d8133cccf5cbe5dc75360ce8",
+        "sha256_in_prefix": "64f2bbf22447c293a26c309459ac6ed5a77912c2d8133cccf5cbe5dc75360ce8",
+        "size_in_bytes": 3660
+      },
+      {
+        "_path": "Library/include/openssl/asn1.h",
+        "path_type": "hardlink",
+        "sha256": "21c06736d3f32822f41c5d9e2db3f84c2f97299f2feac252d724c3e5b6ab3aec",
+        "sha256_in_prefix": "21c06736d3f32822f41c5d9e2db3f84c2f97299f2feac252d724c3e5b6ab3aec",
+        "size_in_bytes": 62042
+      },
+      {
+        "_path": "Library/include/openssl/asn1_mac.h",
+        "path_type": "hardlink",
+        "sha256": "5a0d1d59316bc398bc63af0f1dcf377fb66c3e3132d4c45400c9dbc2003e24b5",
+        "sha256_in_prefix": "5a0d1d59316bc398bc63af0f1dcf377fb66c3e3132d4c45400c9dbc2003e24b5",
+        "size_in_bytes": 398
+      },
+      {
+        "_path": "Library/include/openssl/asn1err.h",
+        "path_type": "hardlink",
+        "sha256": "75c4b045fef75587c0df5c658b7466b74ad42755368a56cf6ff43581aa5768c6",
+        "sha256_in_prefix": "75c4b045fef75587c0df5c658b7466b74ad42755368a56cf6ff43581aa5768c6",
+        "size_in_bytes": 7731
+      },
+      {
+        "_path": "Library/include/openssl/asn1t.h",
+        "path_type": "hardlink",
+        "sha256": "03fcf37af6248fad3421306aa87d1bb2365a4b29f4f7be035d87651e42ed012c",
+        "sha256_in_prefix": "03fcf37af6248fad3421306aa87d1bb2365a4b29f4f7be035d87651e42ed012c",
+        "size_in_bytes": 36883
+      },
+      {
+        "_path": "Library/include/openssl/async.h",
+        "path_type": "hardlink",
+        "sha256": "49369e1569d424f56f016865a34d59b676984e7f67f459e6514241afcd818252",
+        "sha256_in_prefix": "49369e1569d424f56f016865a34d59b676984e7f67f459e6514241afcd818252",
+        "size_in_bytes": 3163
+      },
+      {
+        "_path": "Library/include/openssl/asyncerr.h",
+        "path_type": "hardlink",
+        "sha256": "154f003cfbf49040a04d9aac459cf5009a5a1d76298b222d66ba5b5a4e3721af",
+        "sha256_in_prefix": "154f003cfbf49040a04d9aac459cf5009a5a1d76298b222d66ba5b5a4e3721af",
+        "size_in_bytes": 842
+      },
+      {
+        "_path": "Library/include/openssl/bio.h",
+        "path_type": "hardlink",
+        "sha256": "a679845c227343294780919c2fc7c94a58cade652753ae979b6b9560752a3cbe",
+        "sha256_in_prefix": "a679845c227343294780919c2fc7c94a58cade652753ae979b6b9560752a3cbe",
+        "size_in_bytes": 40731
+      },
+      {
+        "_path": "Library/include/openssl/bioerr.h",
+        "path_type": "hardlink",
+        "sha256": "348571893bca9600b9f790af5c6a02b40bffd83a718450a54a8022c70fef1a14",
+        "sha256_in_prefix": "348571893bca9600b9f790af5c6a02b40bffd83a718450a54a8022c70fef1a14",
+        "size_in_bytes": 3081
+      },
+      {
+        "_path": "Library/include/openssl/blowfish.h",
+        "path_type": "hardlink",
+        "sha256": "fb4b19b7730d1cc7ff2b9da1435a506ad0ef50263bd168c5ff24214a06580282",
+        "sha256_in_prefix": "fb4b19b7730d1cc7ff2b9da1435a506ad0ef50263bd168c5ff24214a06580282",
+        "size_in_bytes": 2693
+      },
+      {
+        "_path": "Library/include/openssl/bn.h",
+        "path_type": "hardlink",
+        "sha256": "8141d04fc871e83308921c290fea380ce92db4a1e2647c985d2f9dcc2bedb08d",
+        "sha256_in_prefix": "8141d04fc871e83308921c290fea380ce92db4a1e2647c985d2f9dcc2bedb08d",
+        "size_in_bytes": 23689
+      },
+      {
+        "_path": "Library/include/openssl/bnerr.h",
+        "path_type": "hardlink",
+        "sha256": "f0dfac26985a7ae40174e90173df9f95b15bba4d3768290746d7258ff1b0ae64",
+        "sha256_in_prefix": "f0dfac26985a7ae40174e90173df9f95b15bba4d3768290746d7258ff1b0ae64",
+        "size_in_bytes": 1949
+      },
+      {
+        "_path": "Library/include/openssl/buffer.h",
+        "path_type": "hardlink",
+        "sha256": "c87b52702746e224e6242f4a2a2070b007502ea92063b41df2c4f6bec11c37ca",
+        "sha256_in_prefix": "c87b52702746e224e6242f4a2a2070b007502ea92063b41df2c4f6bec11c37ca",
+        "size_in_bytes": 1658
+      },
+      {
+        "_path": "Library/include/openssl/buffererr.h",
+        "path_type": "hardlink",
+        "sha256": "73f33a7b4406477a0eaf9d0ec42f43b2594167b1d6b84175f378cf5b0de07c12",
+        "sha256_in_prefix": "73f33a7b4406477a0eaf9d0ec42f43b2594167b1d6b84175f378cf5b0de07c12",
+        "size_in_bytes": 594
+      },
+      {
+        "_path": "Library/include/openssl/camellia.h",
+        "path_type": "hardlink",
+        "sha256": "d1cee6e44668fba0e46c38db7394aa094c6cd2a25b97dbcfcc6f0ff4414f8ebf",
+        "sha256_in_prefix": "d1cee6e44668fba0e46c38db7394aa094c6cd2a25b97dbcfcc6f0ff4414f8ebf",
+        "size_in_bytes": 5069
+      },
+      {
+        "_path": "Library/include/openssl/cast.h",
+        "path_type": "hardlink",
+        "sha256": "654ac650ae74ca5e9a87ab46c1205157a7489097d005fdccc4c52912cfcefa55",
+        "sha256_in_prefix": "654ac650ae74ca5e9a87ab46c1205157a7489097d005fdccc4c52912cfcefa55",
+        "size_in_bytes": 2066
+      },
+      {
+        "_path": "Library/include/openssl/cmac.h",
+        "path_type": "hardlink",
+        "sha256": "b26f8ddb9f60eef2601a84a5455c11060e028d8ce700cae682c4a02ffe2f2ca2",
+        "sha256_in_prefix": "b26f8ddb9f60eef2601a84a5455c11060e028d8ce700cae682c4a02ffe2f2ca2",
+        "size_in_bytes": 1608
+      },
+      {
+        "_path": "Library/include/openssl/cmp.h",
+        "path_type": "hardlink",
+        "sha256": "0f04b773fea93ee353b53274c56c43e7f969df2eaae697a6399faa43fb9f59c0",
+        "sha256_in_prefix": "0f04b773fea93ee353b53274c56c43e7f969df2eaae697a6399faa43fb9f59c0",
+        "size_in_bytes": 41720
+      },
+      {
+        "_path": "Library/include/openssl/cmp_util.h",
+        "path_type": "hardlink",
+        "sha256": "7a982bac5840812b486176102b1fe8b48dda8cce0fe94f2d35aff5057a99004e",
+        "sha256_in_prefix": "7a982bac5840812b486176102b1fe8b48dda8cce0fe94f2d35aff5057a99004e",
+        "size_in_bytes": 1742
+      },
+      {
+        "_path": "Library/include/openssl/cmperr.h",
+        "path_type": "hardlink",
+        "sha256": "a15841cd934edf4f79c2f6bde6b08aad01046179774e765295c57efebdb66527",
+        "sha256_in_prefix": "a15841cd934edf4f79c2f6bde6b08aad01046179774e765295c57efebdb66527",
+        "size_in_bytes": 6165
+      },
+      {
+        "_path": "Library/include/openssl/cms.h",
+        "path_type": "hardlink",
+        "sha256": "ce2a0571ff7ad4317ff2fe359e67ea3b1ed0a393a6ff533e37bbe164da7eb53a",
+        "sha256_in_prefix": "ce2a0571ff7ad4317ff2fe359e67ea3b1ed0a393a6ff533e37bbe164da7eb53a",
+        "size_in_bytes": 34574
+      },
+      {
+        "_path": "Library/include/openssl/cmserr.h",
+        "path_type": "hardlink",
+        "sha256": "250953529ec294424fd84e58ebb6c65d1047ff9c78a19c9ba1a2a948bcbbed64",
+        "sha256_in_prefix": "250953529ec294424fd84e58ebb6c65d1047ff9c78a19c9ba1a2a948bcbbed64",
+        "size_in_bytes": 6731
+      },
+      {
+        "_path": "Library/include/openssl/comp.h",
+        "path_type": "hardlink",
+        "sha256": "44ad0613758e8cf84d9ec4f40cf50cbb735b16e659f7e9fd30c2155585d94199",
+        "sha256_in_prefix": "44ad0613758e8cf84d9ec4f40cf50cbb735b16e659f7e9fd30c2155585d94199",
+        "size_in_bytes": 1445
+      },
+      {
+        "_path": "Library/include/openssl/comperr.h",
+        "path_type": "hardlink",
+        "sha256": "656851389d8f21bc80b566248d7849c6b4ecbd5b178592b8e099c6457b37d87c",
+        "sha256_in_prefix": "656851389d8f21bc80b566248d7849c6b4ecbd5b178592b8e099c6457b37d87c",
+        "size_in_bytes": 813
+      },
+      {
+        "_path": "Library/include/openssl/conf.h",
+        "path_type": "hardlink",
+        "sha256": "1c0b5f21e976a113657a915ef396b7e187ce5bdf25235292193743bcab418918",
+        "sha256_in_prefix": "1c0b5f21e976a113657a915ef396b7e187ce5bdf25235292193743bcab418918",
+        "size_in_bytes": 10696
+      },
+      {
+        "_path": "Library/include/openssl/conf_api.h",
+        "path_type": "hardlink",
+        "sha256": "a66bcc69464235679980efc4a687a4fe036388da91173809ca45c0a3cfe47a5b",
+        "sha256_in_prefix": "a66bcc69464235679980efc4a687a4fe036388da91173809ca45c0a3cfe47a5b",
+        "size_in_bytes": 1420
+      },
+      {
+        "_path": "Library/include/openssl/conferr.h",
+        "path_type": "hardlink",
+        "sha256": "a37a9bb4578d1b2b1b373c820eb005dfe022c596f5cc5b7ab80de56a07d62c9b",
+        "sha256_in_prefix": "a37a9bb4578d1b2b1b373c820eb005dfe022c596f5cc5b7ab80de56a07d62c9b",
+        "size_in_bytes": 2265
+      },
+      {
+        "_path": "Library/include/openssl/configuration.h",
+        "path_type": "hardlink",
+        "sha256": "38e00579e78e084386e6bea07b70ae3b2f54c6fc71f40cff717c86c8221fe921",
+        "sha256_in_prefix": "38e00579e78e084386e6bea07b70ae3b2f54c6fc71f40cff717c86c8221fe921",
+        "size_in_bytes": 3327
+      },
+      {
+        "_path": "Library/include/openssl/conftypes.h",
+        "path_type": "hardlink",
+        "sha256": "e8f6697076d2464eaecfe2cdae8d2045388c53da2372fd52df5f6cfdc4d63375",
+        "sha256_in_prefix": "e8f6697076d2464eaecfe2cdae8d2045388c53da2372fd52df5f6cfdc4d63375",
+        "size_in_bytes": 1190
+      },
+      {
+        "_path": "Library/include/openssl/core.h",
+        "path_type": "hardlink",
+        "sha256": "2981b182ac8930f17b136665b61f1c34c0cfdb4e122f19bd75d7ff552ff5e736",
+        "sha256_in_prefix": "2981b182ac8930f17b136665b61f1c34c0cfdb4e122f19bd75d7ff552ff5e736",
+        "size_in_bytes": 8131
+      },
+      {
+        "_path": "Library/include/openssl/core_dispatch.h",
+        "path_type": "hardlink",
+        "sha256": "c736175338055b9ba8811d16db30aa5d3e5f9e2f09000706348a5ba06df44c30",
+        "sha256_in_prefix": "c736175338055b9ba8811d16db30aa5d3e5f9e2f09000706348a5ba06df44c30",
+        "size_in_bytes": 47570
+      },
+      {
+        "_path": "Library/include/openssl/core_names.h",
+        "path_type": "hardlink",
+        "sha256": "2b1676b5ed4d0e418ee4f143f40d5349cccfa5c46e08d34298f2881182da25a0",
+        "sha256_in_prefix": "2b1676b5ed4d0e418ee4f143f40d5349cccfa5c46e08d34298f2881182da25a0",
+        "size_in_bytes": 29014
+      },
+      {
+        "_path": "Library/include/openssl/core_object.h",
+        "path_type": "hardlink",
+        "sha256": "7a7172d30597e3a3e06c4e67a049d1335aa6f7d5b49641abba8fd4d5a1c07563",
+        "sha256_in_prefix": "7a7172d30597e3a3e06c4e67a049d1335aa6f7d5b49641abba8fd4d5a1c07563",
+        "size_in_bytes": 1126
+      },
+      {
+        "_path": "Library/include/openssl/crmf.h",
+        "path_type": "hardlink",
+        "sha256": "269055b929140313b60c007a191d2b80be45edf36c7a66fae300d4e78c92ec9d",
+        "sha256_in_prefix": "269055b929140313b60c007a191d2b80be45edf36c7a66fae300d4e78c92ec9d",
+        "size_in_bytes": 14871
+      },
+      {
+        "_path": "Library/include/openssl/crmferr.h",
+        "path_type": "hardlink",
+        "sha256": "c08a40103c0c6d0d7d9ad0e2781db1f19829d29193d115d38b4d0271d13fecf9",
+        "sha256_in_prefix": "c08a40103c0c6d0d7d9ad0e2781db1f19829d29193d115d38b4d0271d13fecf9",
+        "size_in_bytes": 2011
+      },
+      {
+        "_path": "Library/include/openssl/crypto.h",
+        "path_type": "hardlink",
+        "sha256": "51a8c99312d5c36ecbed1c96a1786b26c7949dadc0c8494c67523643e4db9c5c",
+        "sha256_in_prefix": "51a8c99312d5c36ecbed1c96a1786b26c7949dadc0c8494c67523643e4db9c5c",
+        "size_in_bytes": 24503
+      },
+      {
+        "_path": "Library/include/openssl/cryptoerr.h",
+        "path_type": "hardlink",
+        "sha256": "4e7759de28d9f389122c9f5adc93fc20eef7b6619594b1c96c7904b421450d4b",
+        "sha256_in_prefix": "4e7759de28d9f389122c9f5adc93fc20eef7b6619594b1c96c7904b421450d4b",
+        "size_in_bytes": 1899
+      },
+      {
+        "_path": "Library/include/openssl/cryptoerr_legacy.h",
+        "path_type": "hardlink",
+        "sha256": "870042252331e89723d31079469104cafd676f0fedcbe0d99f56f3e8862fff8d",
+        "sha256_in_prefix": "870042252331e89723d31079469104cafd676f0fedcbe0d99f56f3e8862fff8d",
+        "size_in_bytes": 80396
+      },
+      {
+        "_path": "Library/include/openssl/ct.h",
+        "path_type": "hardlink",
+        "sha256": "9b9c6df74d9d7ecee8dc17e68a561f9bae901797525f9b28e88c24a7866cbe07",
+        "sha256_in_prefix": "9b9c6df74d9d7ecee8dc17e68a561f9bae901797525f9b28e88c24a7866cbe07",
+        "size_in_bytes": 23338
+      },
+      {
+        "_path": "Library/include/openssl/cterr.h",
+        "path_type": "hardlink",
+        "sha256": "562bfe4ac984ebfef4fb91bdbe0a649d157f5057ab61ffee3a844d23f7c72c0a",
+        "sha256_in_prefix": "562bfe4ac984ebfef4fb91bdbe0a649d157f5057ab61ffee3a844d23f7c72c0a",
+        "size_in_bytes": 1688
+      },
+      {
+        "_path": "Library/include/openssl/decoder.h",
+        "path_type": "hardlink",
+        "sha256": "8419fd9e4e333fd477238bbad4ff875d5657b02cc39635c3a5c15f3a5bc7f0f2",
+        "sha256_in_prefix": "8419fd9e4e333fd477238bbad4ff875d5657b02cc39635c3a5c15f3a5bc7f0f2",
+        "size_in_bytes": 5760
+      },
+      {
+        "_path": "Library/include/openssl/decodererr.h",
+        "path_type": "hardlink",
+        "sha256": "a785fb95930e8b4a18054f77b7d5143d44673f4ca57682899bc2bf3464cafccf",
+        "sha256_in_prefix": "a785fb95930e8b4a18054f77b7d5143d44673f4ca57682899bc2bf3464cafccf",
+        "size_in_bytes": 791
+      },
+      {
+        "_path": "Library/include/openssl/des.h",
+        "path_type": "hardlink",
+        "sha256": "bb13c7c5e13f3402d674fa88994b92ed72d6cdc1116707765d28bd7e0de31285",
+        "sha256_in_prefix": "bb13c7c5e13f3402d674fa88994b92ed72d6cdc1116707765d28bd7e0de31285",
+        "size_in_bytes": 8525
+      },
+      {
+        "_path": "Library/include/openssl/dh.h",
+        "path_type": "hardlink",
+        "sha256": "a007f31faa72a53ad0b85688287a231898d78048e49dd17f8e75f0b4338b151c",
+        "sha256_in_prefix": "a007f31faa72a53ad0b85688287a231898d78048e49dd17f8e75f0b4338b151c",
+        "size_in_bytes": 15297
+      },
+      {
+        "_path": "Library/include/openssl/dherr.h",
+        "path_type": "hardlink",
+        "sha256": "1fdb17fb97cdfb1a5db6a29fb34f77e625a4592614d31b6bd7efb334492f5cf3",
+        "sha256_in_prefix": "1fdb17fb97cdfb1a5db6a29fb34f77e625a4592614d31b6bd7efb334492f5cf3",
+        "size_in_bytes": 2507
+      },
+      {
+        "_path": "Library/include/openssl/dsa.h",
+        "path_type": "hardlink",
+        "sha256": "28e92a797490e0fd3ba888803fec0104c242149bf922b1b447325efbde0c12d8",
+        "sha256_in_prefix": "28e92a797490e0fd3ba888803fec0104c242149bf922b1b447325efbde0c12d8",
+        "size_in_bytes": 12442
+      },
+      {
+        "_path": "Library/include/openssl/dsaerr.h",
+        "path_type": "hardlink",
+        "sha256": "69c2ecff5f62898461bc521ea918abd2a673206dd5e8d43288ad25d2c012f163",
+        "sha256_in_prefix": "69c2ecff5f62898461bc521ea918abd2a673206dd5e8d43288ad25d2c012f163",
+        "size_in_bytes": 1629
+      },
+      {
+        "_path": "Library/include/openssl/dtls1.h",
+        "path_type": "hardlink",
+        "sha256": "1d1f404032a9eb31408c1f10bdff554d5740fb345b64b86fb74da8df95fbd901",
+        "sha256_in_prefix": "1d1f404032a9eb31408c1f10bdff554d5740fb345b64b86fb74da8df95fbd901",
+        "size_in_bytes": 1465
+      },
+      {
+        "_path": "Library/include/openssl/e_os2.h",
+        "path_type": "hardlink",
+        "sha256": "a5c404e815f8ea17c46ed1b78118f32c2e31fd3ce42f761af2bf8fb5a5864550",
+        "sha256_in_prefix": "a5c404e815f8ea17c46ed1b78118f32c2e31fd3ce42f761af2bf8fb5a5864550",
+        "size_in_bytes": 8718
+      },
+      {
+        "_path": "Library/include/openssl/ebcdic.h",
+        "path_type": "hardlink",
+        "sha256": "75a668c25c97853d5ba37ebce060a15152573242e3729d42830eba1daa642404",
+        "sha256_in_prefix": "75a668c25c97853d5ba37ebce060a15152573242e3729d42830eba1daa642404",
+        "size_in_bytes": 1042
+      },
+      {
+        "_path": "Library/include/openssl/ec.h",
+        "path_type": "hardlink",
+        "sha256": "b863eb4d76d0ac3a6465e859de128549e169eec280f029a22404321a6ebb1b80",
+        "sha256_in_prefix": "b863eb4d76d0ac3a6465e859de128549e169eec280f029a22404321a6ebb1b80",
+        "size_in_bytes": 67683
+      },
+      {
+        "_path": "Library/include/openssl/ecdh.h",
+        "path_type": "hardlink",
+        "sha256": "5b99fdd1dfea38640ed8a506fb9b66db381cc26a1254448a81cc6b161e41850f",
+        "sha256_in_prefix": "5b99fdd1dfea38640ed8a506fb9b66db381cc26a1254448a81cc6b161e41850f",
+        "size_in_bytes": 361
+      },
+      {
+        "_path": "Library/include/openssl/ecdsa.h",
+        "path_type": "hardlink",
+        "sha256": "5b99fdd1dfea38640ed8a506fb9b66db381cc26a1254448a81cc6b161e41850f",
+        "sha256_in_prefix": "5b99fdd1dfea38640ed8a506fb9b66db381cc26a1254448a81cc6b161e41850f",
+        "size_in_bytes": 361
+      },
+      {
+        "_path": "Library/include/openssl/ecerr.h",
+        "path_type": "hardlink",
+        "sha256": "ce4fec7ee41de25a20abb7a9f00fe93305793a7bd2023d434b9aa6f64f91058a",
+        "sha256_in_prefix": "ce4fec7ee41de25a20abb7a9f00fe93305793a7bd2023d434b9aa6f64f91058a",
+        "size_in_bytes": 5405
+      },
+      {
+        "_path": "Library/include/openssl/encoder.h",
+        "path_type": "hardlink",
+        "sha256": "907d2f061c2972447d3f0c1cfc149c78791b1e4bdc131ad5a3eed1d084c76b41",
+        "sha256_in_prefix": "907d2f061c2972447d3f0c1cfc149c78791b1e4bdc131ad5a3eed1d084c76b41",
+        "size_in_bytes": 5450
+      },
+      {
+        "_path": "Library/include/openssl/encodererr.h",
+        "path_type": "hardlink",
+        "sha256": "63504766e9fcf36fe1527d95fe21460574896da187c60707bfa68254a35693b7",
+        "sha256_in_prefix": "63504766e9fcf36fe1527d95fe21460574896da187c60707bfa68254a35693b7",
+        "size_in_bytes": 791
+      },
+      {
+        "_path": "Library/include/openssl/engine.h",
+        "path_type": "hardlink",
+        "sha256": "11530c79754e3d241cb277d6bc9c9a3f6eb382db53513877b40488908e243556",
+        "sha256_in_prefix": "11530c79754e3d241cb277d6bc9c9a3f6eb382db53513877b40488908e243556",
+        "size_in_bytes": 38821
+      },
+      {
+        "_path": "Library/include/openssl/engineerr.h",
+        "path_type": "hardlink",
+        "sha256": "8616a93b1b1bd8d1221844834817c28b7da78be1649a5b1780d9ea65fba8807c",
+        "sha256_in_prefix": "8616a93b1b1bd8d1221844834817c28b7da78be1649a5b1780d9ea65fba8807c",
+        "size_in_bytes": 2838
+      },
+      {
+        "_path": "Library/include/openssl/err.h",
+        "path_type": "hardlink",
+        "sha256": "67f9f3f83f70524dee7166010dbb59bf7bf1bed385b625b0993e67bf440a7084",
+        "sha256_in_prefix": "67f9f3f83f70524dee7166010dbb59bf7bf1bed385b625b0993e67bf440a7084",
+        "size_in_bytes": 22482
+      },
+      {
+        "_path": "Library/include/openssl/ess.h",
+        "path_type": "hardlink",
+        "sha256": "494f87fe22195a9756db7e603b7e53f2c26145da37ab6e274400929e7bf3cc50",
+        "sha256_in_prefix": "494f87fe22195a9756db7e603b7e53f2c26145da37ab6e274400929e7bf3cc50",
+        "size_in_bytes": 9096
+      },
+      {
+        "_path": "Library/include/openssl/esserr.h",
+        "path_type": "hardlink",
+        "sha256": "e791193e891b0784670d5410539aeea9d2a8591de71495b4add6e7dbf9dc22cd",
+        "sha256_in_prefix": "e791193e891b0784670d5410539aeea9d2a8591de71495b4add6e7dbf9dc22cd",
+        "size_in_bytes": 1144
+      },
+      {
+        "_path": "Library/include/openssl/evp.h",
+        "path_type": "hardlink",
+        "sha256": "21f9783955cd806e69b09ad6fbc956e7f2dc18f8804a4132e2ea0f37492d0c59",
+        "sha256_in_prefix": "21f9783955cd806e69b09ad6fbc956e7f2dc18f8804a4132e2ea0f37492d0c59",
+        "size_in_bytes": 103745
+      },
+      {
+        "_path": "Library/include/openssl/evperr.h",
+        "path_type": "hardlink",
+        "sha256": "7fab5bade4441300fa7ffe721ca2eb361835998db7d386f8f1be7db5b7596c3f",
+        "sha256_in_prefix": "7fab5bade4441300fa7ffe721ca2eb361835998db7d386f8f1be7db5b7596c3f",
+        "size_in_bytes": 7351
+      },
+      {
+        "_path": "Library/include/openssl/fips_names.h",
+        "path_type": "hardlink",
+        "sha256": "2d9f27ed8c44edc185101da548f533d0dbee1435fd8cdb7ad8f02690d31cd20b",
+        "sha256_in_prefix": "2d9f27ed8c44edc185101da548f533d0dbee1435fd8cdb7ad8f02690d31cd20b",
+        "size_in_bytes": 1679
+      },
+      {
+        "_path": "Library/include/openssl/fipskey.h",
+        "path_type": "hardlink",
+        "sha256": "be2cbfd5e3a82d97566c390cb881cded2136edad5d12783c8419da623b18ac66",
+        "sha256_in_prefix": "be2cbfd5e3a82d97566c390cb881cded2136edad5d12783c8419da623b18ac66",
+        "size_in_bytes": 1046
+      },
+      {
+        "_path": "Library/include/openssl/hmac.h",
+        "path_type": "hardlink",
+        "sha256": "e49fbe0086f8fbefa5648eef70bc84e8090a9226a1e3c6e856499373004aed0a",
+        "sha256_in_prefix": "e49fbe0086f8fbefa5648eef70bc84e8090a9226a1e3c6e856499373004aed0a",
+        "size_in_bytes": 2141
+      },
+      {
+        "_path": "Library/include/openssl/http.h",
+        "path_type": "hardlink",
+        "sha256": "dd409efeca44be216a7af99b9f39653a5129bfc05f415d6dfaec17758641e1ca",
+        "sha256_in_prefix": "dd409efeca44be216a7af99b9f39653a5129bfc05f415d6dfaec17758641e1ca",
+        "size_in_bytes": 5346
+      },
+      {
+        "_path": "Library/include/openssl/httperr.h",
+        "path_type": "hardlink",
+        "sha256": "b50562e98d92c08e47e2b1b0bcf5652820b2a774652968a1188f9f2d87f2fe87",
+        "sha256_in_prefix": "b50562e98d92c08e47e2b1b0bcf5652820b2a774652968a1188f9f2d87f2fe87",
+        "size_in_bytes": 2451
+      },
+      {
+        "_path": "Library/include/openssl/idea.h",
+        "path_type": "hardlink",
+        "sha256": "239122df15e738d7552dd76850c55a9ffe0136f33506c23d9058215a1255af66",
+        "sha256_in_prefix": "239122df15e738d7552dd76850c55a9ffe0136f33506c23d9058215a1255af66",
+        "size_in_bytes": 3010
+      },
+      {
+        "_path": "Library/include/openssl/kdf.h",
+        "path_type": "hardlink",
+        "sha256": "41756fe038443d1d270458d53d6e42ea78d12d980728b6a9284fa259958ea00a",
+        "sha256_in_prefix": "41756fe038443d1d270458d53d6e42ea78d12d980728b6a9284fa259958ea00a",
+        "size_in_bytes": 5619
+      },
+      {
+        "_path": "Library/include/openssl/kdferr.h",
+        "path_type": "hardlink",
+        "sha256": "3d9f27fffdb49e0ece9d5a62adbb9cc42c56262b00cc8ce7f956b2cb05a2a22d",
+        "sha256_in_prefix": "3d9f27fffdb49e0ece9d5a62adbb9cc42c56262b00cc8ce7f956b2cb05a2a22d",
+        "size_in_bytes": 482
+      },
+      {
+        "_path": "Library/include/openssl/lhash.h",
+        "path_type": "hardlink",
+        "sha256": "324cd5a7b872adaca791a58cb0f58177397667360326c215f2aba17650806a32",
+        "sha256_in_prefix": "324cd5a7b872adaca791a58cb0f58177397667360326c215f2aba17650806a32",
+        "size_in_bytes": 14349
+      },
+      {
+        "_path": "Library/include/openssl/macros.h",
+        "path_type": "hardlink",
+        "sha256": "e480df214285bb3225da7549c0468590f7156ca399591167ee41360936264c46",
+        "sha256_in_prefix": "e480df214285bb3225da7549c0468590f7156ca399591167ee41360936264c46",
+        "size_in_bytes": 10110
+      },
+      {
+        "_path": "Library/include/openssl/md2.h",
+        "path_type": "hardlink",
+        "sha256": "4add77ed047736979dc442a49d42921cce21e654a2dceef058d0191aa2d3c941",
+        "sha256_in_prefix": "4add77ed047736979dc442a49d42921cce21e654a2dceef058d0191aa2d3c941",
+        "size_in_bytes": 1461
+      },
+      {
+        "_path": "Library/include/openssl/md4.h",
+        "path_type": "hardlink",
+        "sha256": "0472e597d139b44dd7d78d9093a5d8109417d18e9955fc940f1ea3e2e892ab44",
+        "sha256_in_prefix": "0472e597d139b44dd7d78d9093a5d8109417d18e9955fc940f1ea3e2e892ab44",
+        "size_in_bytes": 1699
+      },
+      {
+        "_path": "Library/include/openssl/md5.h",
+        "path_type": "hardlink",
+        "sha256": "308c901ec1a28f9b0098717f689ca63e104ce805050802d38b8f122d85ab2c78",
+        "sha256_in_prefix": "308c901ec1a28f9b0098717f689ca63e104ce805050802d38b8f122d85ab2c78",
+        "size_in_bytes": 1696
+      },
+      {
+        "_path": "Library/include/openssl/mdc2.h",
+        "path_type": "hardlink",
+        "sha256": "42b844c9ae9e00e7c0b0e28858b8b3db7b8abf7e514e5e63f43456371ed3384b",
+        "sha256_in_prefix": "42b844c9ae9e00e7c0b0e28858b8b3db7b8abf7e514e5e63f43456371ed3384b",
+        "size_in_bytes": 1441
+      },
+      {
+        "_path": "Library/include/openssl/modes.h",
+        "path_type": "hardlink",
+        "sha256": "4a8b3b1dafc15798a3b2bef0e3885275746e7fae73a0d96e55da55261554ba52",
+        "sha256_in_prefix": "4a8b3b1dafc15798a3b2bef0e3885275746e7fae73a0d96e55da55261554ba52",
+        "size_in_bytes": 10786
+      },
+      {
+        "_path": "Library/include/openssl/obj_mac.h",
+        "path_type": "hardlink",
+        "sha256": "c1d31f32a3dbc9dea1db10f322b4b46a24c3d4411fe54630df59fa46fc2b583a",
+        "sha256_in_prefix": "c1d31f32a3dbc9dea1db10f322b4b46a24c3d4411fe54630df59fa46fc2b583a",
+        "size_in_bytes": 228668
+      },
+      {
+        "_path": "Library/include/openssl/objects.h",
+        "path_type": "hardlink",
+        "sha256": "5fc6f3f0dd5e46fd409cb51ae1b331fec799fb6ef4b5efdc8ffbe264e5e83997",
+        "sha256_in_prefix": "5fc6f3f0dd5e46fd409cb51ae1b331fec799fb6ef4b5efdc8ffbe264e5e83997",
+        "size_in_bytes": 6848
+      },
+      {
+        "_path": "Library/include/openssl/objectserr.h",
+        "path_type": "hardlink",
+        "sha256": "e17a8d7f62a1ef257fd90e604d4293bf02d5f81ae8198efe1e197c5b27baeb8c",
+        "sha256_in_prefix": "e17a8d7f62a1ef257fd90e604d4293bf02d5f81ae8198efe1e197c5b27baeb8c",
+        "size_in_bytes": 782
+      },
+      {
+        "_path": "Library/include/openssl/ocsp.h",
+        "path_type": "hardlink",
+        "sha256": "01aa2aa17ccad22ebc1a1701ad27b67a165a0c23f9e50fe5ad86b4e90ef190b9",
+        "sha256_in_prefix": "01aa2aa17ccad22ebc1a1701ad27b67a165a0c23f9e50fe5ad86b4e90ef190b9",
+        "size_in_bytes": 29835
+      },
+      {
+        "_path": "Library/include/openssl/ocsperr.h",
+        "path_type": "hardlink",
+        "sha256": "178329cfc042d3f1eb6e179206d844de41ba05ee4ac0ed9e3e6c861fb49d68ea",
+        "sha256_in_prefix": "178329cfc042d3f1eb6e179206d844de41ba05ee4ac0ed9e3e6c861fb49d68ea",
+        "size_in_bytes": 2200
+      },
+      {
+        "_path": "Library/include/openssl/opensslconf.h",
+        "path_type": "hardlink",
+        "sha256": "890184233890bacd52fd420fef07befad411b9a318b97efbf36f46673d3e7841",
+        "sha256_in_prefix": "890184233890bacd52fd420fef07befad411b9a318b97efbf36f46673d3e7841",
+        "size_in_bytes": 515
+      },
+      {
+        "_path": "Library/include/openssl/opensslv.h",
+        "path_type": "hardlink",
+        "sha256": "a391f18a4c6ec350719dbdb80c4edd4b8d7ea5cf0e58ae72f3ace47f4271f68b",
+        "sha256_in_prefix": "a391f18a4c6ec350719dbdb80c4edd4b8d7ea5cf0e58ae72f3ace47f4271f68b",
+        "size_in_bytes": 3304
+      },
+      {
+        "_path": "Library/include/openssl/ossl_typ.h",
+        "path_type": "hardlink",
+        "sha256": "76cb203ef3bcd305f4171e1d33f3f3319dee6354c2433493e5e9068aa79672fd",
+        "sha256_in_prefix": "76cb203ef3bcd305f4171e1d33f3f3319dee6354c2433493e5e9068aa79672fd",
+        "size_in_bytes": 562
+      },
+      {
+        "_path": "Library/include/openssl/param_build.h",
+        "path_type": "hardlink",
+        "sha256": "3bf39b1037256466f1a89868621b2b62f1d05e63064159e60727041b170d55e3",
+        "sha256_in_prefix": "3bf39b1037256466f1a89868621b2b62f1d05e63064159e60727041b170d55e3",
+        "size_in_bytes": 2809
+      },
+      {
+        "_path": "Library/include/openssl/params.h",
+        "path_type": "hardlink",
+        "sha256": "10d8e0157e339ee01f3b9c60c4b5bc60e6d4edce1084f0c9589ff75bf3a9f693",
+        "sha256_in_prefix": "10d8e0157e339ee01f3b9c60c4b5bc60e6d4edce1084f0c9589ff75bf3a9f693",
+        "size_in_bytes": 7328
+      },
+      {
+        "_path": "Library/include/openssl/pem.h",
+        "path_type": "hardlink",
+        "sha256": "9ae49f961842fa3e2e76ea796e48b2a984e2a66dc0c266a52d01ac7bab5bd9f1",
+        "sha256_in_prefix": "9ae49f961842fa3e2e76ea796e48b2a984e2a66dc0c266a52d01ac7bab5bd9f1",
+        "size_in_bytes": 25764
+      },
+      {
+        "_path": "Library/include/openssl/pem2.h",
+        "path_type": "hardlink",
+        "sha256": "a34a1607983b5f32be8ca49e75c3b41f1c9413b4eb777af144958283ecbd3922",
+        "sha256_in_prefix": "a34a1607983b5f32be8ca49e75c3b41f1c9413b4eb777af144958283ecbd3922",
+        "size_in_bytes": 531
+      },
+      {
+        "_path": "Library/include/openssl/pemerr.h",
+        "path_type": "hardlink",
+        "sha256": "843df90b1b434eed626bb6b8bccd5f6ed530e592d706584f56a725d254d8a5d2",
+        "sha256_in_prefix": "843df90b1b434eed626bb6b8bccd5f6ed530e592d706584f56a725d254d8a5d2",
+        "size_in_bytes": 2634
+      },
+      {
+        "_path": "Library/include/openssl/pkcs12.h",
+        "path_type": "hardlink",
+        "sha256": "72724303808766cc0a5a72f48ad5b1eb219ca4685a5fc5574d038214614d1a83",
+        "sha256_in_prefix": "72724303808766cc0a5a72f48ad5b1eb219ca4685a5fc5574d038214614d1a83",
+        "size_in_bytes": 19666
+      },
+      {
+        "_path": "Library/include/openssl/pkcs12err.h",
+        "path_type": "hardlink",
+        "sha256": "b692b1a2c7fc06002dee07a868f0ec394e9b7f20b5e151f78e0941e143c2d2d4",
+        "sha256_in_prefix": "b692b1a2c7fc06002dee07a868f0ec394e9b7f20b5e151f78e0941e143c2d2d4",
+        "size_in_bytes": 1837
+      },
+      {
+        "_path": "Library/include/openssl/pkcs7.h",
+        "path_type": "hardlink",
+        "sha256": "dc51d4166e9450f1c9c4a80bda105a953fe7db8a48a6e5d6c1266ef40f4807f2",
+        "sha256_in_prefix": "dc51d4166e9450f1c9c4a80bda105a953fe7db8a48a6e5d6c1266ef40f4807f2",
+        "size_in_bytes": 22849
+      },
+      {
+        "_path": "Library/include/openssl/pkcs7err.h",
+        "path_type": "hardlink",
+        "sha256": "9fe7a51f3de13b1fd03b319c64b8bd287164eb6ce7d3481994141c0be51396d5",
+        "sha256_in_prefix": "9fe7a51f3de13b1fd03b319c64b8bd287164eb6ce7d3481994141c0be51396d5",
+        "size_in_bytes": 2952
+      },
+      {
+        "_path": "Library/include/openssl/prov_ssl.h",
+        "path_type": "hardlink",
+        "sha256": "1f5c121c02d31f695bff708396e0512286fa04dee67f12ab895c0c558ba33f20",
+        "sha256_in_prefix": "1f5c121c02d31f695bff708396e0512286fa04dee67f12ab895c0c558ba33f20",
+        "size_in_bytes": 981
+      },
+      {
+        "_path": "Library/include/openssl/proverr.h",
+        "path_type": "hardlink",
+        "sha256": "adf058748c58f5e0e3446a1af743ea70e4387a95ddc0d08d9ceddf79a87ac517",
+        "sha256_in_prefix": "adf058748c58f5e0e3446a1af743ea70e4387a95ddc0d08d9ceddf79a87ac517",
+        "size_in_bytes": 8217
+      },
+      {
+        "_path": "Library/include/openssl/provider.h",
+        "path_type": "hardlink",
+        "sha256": "b9e5b46a26f7e7ec383fe540404092e4d76ae54b5822744e4ba0750ef8d2cac0",
+        "sha256_in_prefix": "b9e5b46a26f7e7ec383fe540404092e4d76ae54b5822744e4ba0750ef8d2cac0",
+        "size_in_bytes": 2325
+      },
+      {
+        "_path": "Library/include/openssl/rand.h",
+        "path_type": "hardlink",
+        "sha256": "85bda3b0a72aedb08cb8b75bb49366e4f8e07599f9dae5df8d688ce57073033f",
+        "sha256_in_prefix": "85bda3b0a72aedb08cb8b75bb49366e4f8e07599f9dae5df8d688ce57073033f",
+        "size_in_bytes": 3860
+      },
+      {
+        "_path": "Library/include/openssl/randerr.h",
+        "path_type": "hardlink",
+        "sha256": "80260d41625b9ed9f727e8553a65a111645b3c013df8cc8fa6a718d32b643c88",
+        "sha256_in_prefix": "80260d41625b9ed9f727e8553a65a111645b3c013df8cc8fa6a718d32b643c88",
+        "size_in_bytes": 3257
+      },
+      {
+        "_path": "Library/include/openssl/rc2.h",
+        "path_type": "hardlink",
+        "sha256": "08c6865d169a300e8bc818bd810f80ffb8a21d69e97dad88e400b586d0f3e965",
+        "sha256_in_prefix": "08c6865d169a300e8bc818bd810f80ffb8a21d69e97dad88e400b586d0f3e965",
+        "size_in_bytes": 2382
+      },
+      {
+        "_path": "Library/include/openssl/rc4.h",
+        "path_type": "hardlink",
+        "sha256": "ea45836c253246c1d6f1b16b360dbb59322e26e28bfc54881d698e7cd5057666",
+        "sha256_in_prefix": "ea45836c253246c1d6f1b16b360dbb59322e26e28bfc54881d698e7cd5057666",
+        "size_in_bytes": 1194
+      },
+      {
+        "_path": "Library/include/openssl/rc5.h",
+        "path_type": "hardlink",
+        "sha256": "968c96ead08204edb8148981094700cbc3338ed0613c4469da5ab4675fa1ce29",
+        "sha256_in_prefix": "968c96ead08204edb8148981094700cbc3338ed0613c4469da5ab4675fa1ce29",
+        "size_in_bytes": 2861
+      },
+      {
+        "_path": "Library/include/openssl/ripemd.h",
+        "path_type": "hardlink",
+        "sha256": "2e28edeb6613516db89e28c9d962301f4fe7b38366ebdd1d35933f3491d57b9d",
+        "sha256_in_prefix": "2e28edeb6613516db89e28c9d962301f4fe7b38366ebdd1d35933f3491d57b9d",
+        "size_in_bytes": 1717
+      },
+      {
+        "_path": "Library/include/openssl/rsa.h",
+        "path_type": "hardlink",
+        "sha256": "55aa4b44d21ebb0d7cbc54273f0cf6032c449f5055cfae6793c5b68a682d6692",
+        "sha256_in_prefix": "55aa4b44d21ebb0d7cbc54273f0cf6032c449f5055cfae6793c5b68a682d6692",
+        "size_in_bytes": 28136
+      },
+      {
+        "_path": "Library/include/openssl/rsaerr.h",
+        "path_type": "hardlink",
+        "sha256": "a745e6b2835af7bb933e78870a270d51ab33778fe10a5cd377422d4b9587dcf0",
+        "sha256_in_prefix": "a745e6b2835af7bb933e78870a270d51ab33778fe10a5cd377422d4b9587dcf0",
+        "size_in_bytes": 5681
+      },
+      {
+        "_path": "Library/include/openssl/safestack.h",
+        "path_type": "hardlink",
+        "sha256": "1089ec732df2ababf7185ecf93660a5a8e2cf6d84eee3097afa514086cde7cb5",
+        "sha256_in_prefix": "1089ec732df2ababf7185ecf93660a5a8e2cf6d84eee3097afa514086cde7cb5",
+        "size_in_bytes": 18736
+      },
+      {
+        "_path": "Library/include/openssl/seed.h",
+        "path_type": "hardlink",
+        "sha256": "0d6d206f240f7bd6fa28cd4ec66b2b878f199af3ce6eda172af9fe31ebb71586",
+        "sha256_in_prefix": "0d6d206f240f7bd6fa28cd4ec66b2b878f199af3ce6eda172af9fe31ebb71586",
+        "size_in_bytes": 3964
+      },
+      {
+        "_path": "Library/include/openssl/self_test.h",
+        "path_type": "hardlink",
+        "sha256": "5a77b263ac9a41190c15fc0c6932b0d573d9034d55b401ccdc52858b5ee9c5fc",
+        "sha256_in_prefix": "5a77b263ac9a41190c15fc0c6932b0d573d9034d55b401ccdc52858b5ee9c5fc",
+        "size_in_bytes": 4015
+      },
+      {
+        "_path": "Library/include/openssl/sha.h",
+        "path_type": "hardlink",
+        "sha256": "06500535b9b3d9742e745558dc02e52d0df6d75b038457d4f6c374ed68d39eaf",
+        "sha256_in_prefix": "06500535b9b3d9742e745558dc02e52d0df6d75b038457d4f6c374ed68d39eaf",
+        "size_in_bytes": 4658
+      },
+      {
+        "_path": "Library/include/openssl/srp.h",
+        "path_type": "hardlink",
+        "sha256": "8b4982b2f881ef4234279e1fe31634848a64db40d66762c2e396a4f8beafb296",
+        "sha256_in_prefix": "8b4982b2f881ef4234279e1fe31634848a64db40d66762c2e396a4f8beafb296",
+        "size_in_bytes": 15772
+      },
+      {
+        "_path": "Library/include/openssl/srtp.h",
+        "path_type": "hardlink",
+        "sha256": "d2b97e90531bf9cdb086d9943a518bc474aebaa0aef02f1d41e8113fe944c9d9",
+        "sha256_in_prefix": "d2b97e90531bf9cdb086d9943a518bc474aebaa0aef02f1d41e8113fe944c9d9",
+        "size_in_bytes": 1429
+      },
+      {
+        "_path": "Library/include/openssl/ssl.h",
+        "path_type": "hardlink",
+        "sha256": "4cc6ef3fd3be5fcd8707cd01a0b972a9ec4bb13e01c0a858c88170fd77d3a484",
+        "sha256_in_prefix": "4cc6ef3fd3be5fcd8707cd01a0b972a9ec4bb13e01c0a858c88170fd77d3a484",
+        "size_in_bytes": 127537
+      },
+      {
+        "_path": "Library/include/openssl/ssl2.h",
+        "path_type": "hardlink",
+        "sha256": "92e3330e2867bf17d3b305ba0f6fe6b073ad4bdb9db519e4224bbd993f1e9cb7",
+        "sha256_in_prefix": "92e3330e2867bf17d3b305ba0f6fe6b073ad4bdb9db519e4224bbd993f1e9cb7",
+        "size_in_bytes": 658
+      },
+      {
+        "_path": "Library/include/openssl/ssl3.h",
+        "path_type": "hardlink",
+        "sha256": "5ce26c99d8a0fffe062a4293f01f6d55619b4e1b8f75bf0065fb3faa2ac512e9",
+        "sha256_in_prefix": "5ce26c99d8a0fffe062a4293f01f6d55619b4e1b8f75bf0065fb3faa2ac512e9",
+        "size_in_bytes": 14773
+      },
+      {
+        "_path": "Library/include/openssl/sslerr.h",
+        "path_type": "hardlink",
+        "sha256": "f81905743cb44b6a82f79a6edba7a879740da8cfc69b20d5a51a0e27f325f54a",
+        "sha256_in_prefix": "f81905743cb44b6a82f79a6edba7a879740da8cfc69b20d5a51a0e27f325f54a",
+        "size_in_bytes": 20527
+      },
+      {
+        "_path": "Library/include/openssl/sslerr_legacy.h",
+        "path_type": "hardlink",
+        "sha256": "98401ca29f46694fff11304801d995015a7e4a81afe0db0a9a79a0bdde9e03d8",
+        "sha256_in_prefix": "98401ca29f46694fff11304801d995015a7e4a81afe0db0a9a79a0bdde9e03d8",
+        "size_in_bytes": 27005
+      },
+      {
+        "_path": "Library/include/openssl/stack.h",
+        "path_type": "hardlink",
+        "sha256": "69f94382a15a3c4cfd1dda32108db5234727b36ed0e25f1fb12e0993c7b5ac95",
+        "sha256_in_prefix": "69f94382a15a3c4cfd1dda32108db5234727b36ed0e25f1fb12e0993c7b5ac95",
+        "size_in_bytes": 3284
+      },
+      {
+        "_path": "Library/include/openssl/store.h",
+        "path_type": "hardlink",
+        "sha256": "cfd4ee1777782d642da53a045d253ede58f0f0463647e6d4f352953b26e2e058",
+        "sha256_in_prefix": "cfd4ee1777782d642da53a045d253ede58f0f0463647e6d4f352953b26e2e058",
+        "size_in_bytes": 15178
+      },
+      {
+        "_path": "Library/include/openssl/storeerr.h",
+        "path_type": "hardlink",
+        "sha256": "370277e107a1b979ff5e0bd28f5adb92e066d41831ac37ce7108d2a1b84376f6",
+        "sha256_in_prefix": "370277e107a1b979ff5e0bd28f5adb92e066d41831ac37ce7108d2a1b84376f6",
+        "size_in_bytes": 2092
+      },
+      {
+        "_path": "Library/include/openssl/symhacks.h",
+        "path_type": "hardlink",
+        "sha256": "68b54776fa15943f3f018be6c7dc7a8847c9f512fb5eeec4f093804197dc2dfa",
+        "sha256_in_prefix": "68b54776fa15943f3f018be6c7dc7a8847c9f512fb5eeec4f093804197dc2dfa",
+        "size_in_bytes": 1290
+      },
+      {
+        "_path": "Library/include/openssl/tls1.h",
+        "path_type": "hardlink",
+        "sha256": "3b00ace186f249ab037b165847a1e100705ce23464d1e12bb40d55dd421de33c",
+        "sha256_in_prefix": "3b00ace186f249ab037b165847a1e100705ce23464d1e12bb40d55dd421de33c",
+        "size_in_bytes": 71796
+      },
+      {
+        "_path": "Library/include/openssl/trace.h",
+        "path_type": "hardlink",
+        "sha256": "ece8835757afceedac1ab80b4081db1a5b9758bd1eab887c00834dd91d4d5339",
+        "sha256_in_prefix": "ece8835757afceedac1ab80b4081db1a5b9758bd1eab887c00834dd91d4d5339",
+        "size_in_bytes": 10277
+      },
+      {
+        "_path": "Library/include/openssl/ts.h",
+        "path_type": "hardlink",
+        "sha256": "eca8f795f977a1f52bd84c8c01d2e90686887fc151a9309efdeb95f42d1cd327",
+        "sha256_in_prefix": "eca8f795f977a1f52bd84c8c01d2e90686887fc151a9309efdeb95f42d1cd327",
+        "size_in_bytes": 19706
+      },
+      {
+        "_path": "Library/include/openssl/tserr.h",
+        "path_type": "hardlink",
+        "sha256": "0d851cb9db84c48bb8a9871a988950fd0b62ecc854b11641e3e9a07fa191a6f6",
+        "sha256_in_prefix": "0d851cb9db84c48bb8a9871a988950fd0b62ecc854b11641e3e9a07fa191a6f6",
+        "size_in_bytes": 3074
+      },
+      {
+        "_path": "Library/include/openssl/txt_db.h",
+        "path_type": "hardlink",
+        "sha256": "1a6a6b331ef3cc6c632f782e8da2fa81aaeeac56e4d0b2fb3016f936805be257",
+        "sha256_in_prefix": "1a6a6b331ef3cc6c632f782e8da2fa81aaeeac56e4d0b2fb3016f936805be257",
+        "size_in_bytes": 1784
+      },
+      {
+        "_path": "Library/include/openssl/types.h",
+        "path_type": "hardlink",
+        "sha256": "4986b31300621b35ddd0e2220fd9943eabc264003d73364282869fbb5c1d4a84",
+        "sha256_in_prefix": "4986b31300621b35ddd0e2220fd9943eabc264003d73364282869fbb5c1d4a84",
+        "size_in_bytes": 7206
+      },
+      {
+        "_path": "Library/include/openssl/ui.h",
+        "path_type": "hardlink",
+        "sha256": "1ec7da15b464387449827771eb3884b3a0f2a66001703809ba4d519e0ba4636a",
+        "sha256_in_prefix": "1ec7da15b464387449827771eb3884b3a0f2a66001703809ba4d519e0ba4636a",
+        "size_in_bytes": 19658
+      },
+      {
+        "_path": "Library/include/openssl/uierr.h",
+        "path_type": "hardlink",
+        "sha256": "6f46dc9509b4d10802aaa1ad3c84763a2843312fdc8dd8add5c7b24e7f0c877f",
+        "sha256_in_prefix": "6f46dc9509b4d10802aaa1ad3c84763a2843312fdc8dd8add5c7b24e7f0c877f",
+        "size_in_bytes": 1391
+      },
+      {
+        "_path": "Library/include/openssl/whrlpool.h",
+        "path_type": "hardlink",
+        "sha256": "bb8f9f6ad1960e87f78363793130a0c1bee89b64a12eb32e939791fb0ca61016",
+        "sha256_in_prefix": "bb8f9f6ad1960e87f78363793130a0c1bee89b64a12eb32e939791fb0ca61016",
+        "size_in_bytes": 1853
+      },
+      {
+        "_path": "Library/include/openssl/x509.h",
+        "path_type": "hardlink",
+        "sha256": "b92a7b83799d075816a2a30fb18c16b1c5ec258bb8debd8056034fc23b33beca",
+        "sha256_in_prefix": "b92a7b83799d075816a2a30fb18c16b1c5ec258bb8debd8056034fc23b33beca",
+        "size_in_bytes": 72824
+      },
+      {
+        "_path": "Library/include/openssl/x509_vfy.h",
+        "path_type": "hardlink",
+        "sha256": "d66e75c6d3914f1115ab98831a1302669787f766cb9a92cda2480a937c766aa0",
+        "sha256_in_prefix": "d66e75c6d3914f1115ab98831a1302669787f766cb9a92cda2480a937c766aa0",
+        "size_in_bytes": 52921
+      },
+      {
+        "_path": "Library/include/openssl/x509err.h",
+        "path_type": "hardlink",
+        "sha256": "a9f2e315eb068c81dd1711a4b2cdc65af0cdd976912704b86f9cd33b341fdd2b",
+        "sha256_in_prefix": "a9f2e315eb068c81dd1711a4b2cdc65af0cdd976912704b86f9cd33b341fdd2b",
+        "size_in_bytes": 3319
+      },
+      {
+        "_path": "Library/include/openssl/x509v3.h",
+        "path_type": "hardlink",
+        "sha256": "461bd457ee55f1c6799620dbe0c136f2ce71d272a79e8c5ea907de58cce6fde6",
+        "sha256_in_prefix": "461bd457ee55f1c6799620dbe0c136f2ce71d272a79e8c5ea907de58cce6fde6",
+        "size_in_bytes": 95418
+      },
+      {
+        "_path": "Library/include/openssl/x509v3err.h",
+        "path_type": "hardlink",
+        "sha256": "25ce00779ee00002830ede3e302a8b4bf03dbc505243d2b87a86a62c31a52d6f",
+        "sha256_in_prefix": "25ce00779ee00002830ede3e302a8b4bf03dbc505243d2b87a86a62c31a52d6f",
+        "size_in_bytes": 4819
+      },
+      {
+        "_path": "Library/lib/libcrypto.lib",
+        "path_type": "hardlink",
+        "sha256": "a27f00999547710cb077d884a6b2d84b516e9cac58117337e4c98a9afd04929d",
+        "sha256_in_prefix": "a27f00999547710cb077d884a6b2d84b516e9cac58117337e4c98a9afd04929d",
+        "size_in_bytes": 1251364
+      },
+      {
+        "_path": "Library/lib/libssl.lib",
+        "path_type": "hardlink",
+        "sha256": "e13eeaef26f2ece820283734db1673eefe8bccf4285785d0459c24cd0488d246",
+        "sha256_in_prefix": "e13eeaef26f2ece820283734db1673eefe8bccf4285785d0459c24cd0488d246",
+        "size_in_bytes": 126434
+      },
+      {
+        "_path": "Library/lib/pkgconfig/libcrypto.pc",
+        "file_mode": "text",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:/b/abs_04f5aioy9i/croot/openssl_1740989503961/_h_env",
+        "sha256": "db5368187590d6411a25e2d17a0b18d6d7ddd7710072265c2fb7586201043129",
+        "sha256_in_prefix": "7fa15e779e4daf45d6c2311773a2f982cb1d2330237a5d5d013944dede876239",
+        "size_in_bytes": 325
+      },
+      {
+        "_path": "Library/lib/pkgconfig/libssl.pc",
+        "file_mode": "text",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:/b/abs_04f5aioy9i/croot/openssl_1740989503961/_h_env",
+        "sha256": "b81642046e735754e996eefcbec141b669a9e33b4ba1facd7bfdc8a4efcdbb19",
+        "sha256_in_prefix": "e0a2ea2952c2c448e3ba1939a5004df1bcd384c355eccd26f0c37bcdc76468b8",
+        "size_in_bytes": 325
+      },
+      {
+        "_path": "Library/lib/pkgconfig/openssl.pc",
+        "file_mode": "text",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:/b/abs_04f5aioy9i/croot/openssl_1740989503961/_h_env",
+        "sha256": "c7932fcc3aa19e36f58cdbb5c8d00ba56b86d301e355aaa0d9e6f138f1373784",
+        "sha256_in_prefix": "6cc4fda64fad0e0eeda051bde8780f8590404650087bdc2d7003d88ea7b6f6af",
+        "size_in_bytes": 280
+      },
+      {
+        "_path": "Library/ssl/ct_log_list.cnf",
+        "path_type": "hardlink",
+        "sha256": "f1c1803d13d1d0b755b13b23c28bd4e20e07baf9f2b744c9337ba5866aa0ec3b",
+        "sha256_in_prefix": "f1c1803d13d1d0b755b13b23c28bd4e20e07baf9f2b744c9337ba5866aa0ec3b",
+        "size_in_bytes": 412
+      },
+      {
+        "_path": "Library/ssl/ct_log_list.cnf.dist",
+        "path_type": "hardlink",
+        "sha256": "f1c1803d13d1d0b755b13b23c28bd4e20e07baf9f2b744c9337ba5866aa0ec3b",
+        "sha256_in_prefix": "f1c1803d13d1d0b755b13b23c28bd4e20e07baf9f2b744c9337ba5866aa0ec3b",
+        "size_in_bytes": 412
+      },
+      {
+        "_path": "Library/ssl/misc/CA.pl",
+        "path_type": "hardlink",
+        "sha256": "2d5ee9f64e008a31b9e67fc140ccb3fe3a40f263e3323747b26c566f17e3488e",
+        "sha256_in_prefix": "2d5ee9f64e008a31b9e67fc140ccb3fe3a40f263e3323747b26c566f17e3488e",
+        "size_in_bytes": 8357
+      },
+      {
+        "_path": "Library/ssl/misc/tsget.pl",
+        "path_type": "hardlink",
+        "sha256": "ed060e36e213b85d7e632450ba2eda5cb9e0917274cf5ea76006022327bb5a87",
+        "sha256_in_prefix": "ed060e36e213b85d7e632450ba2eda5cb9e0917274cf5ea76006022327bb5a87",
+        "size_in_bytes": 7005
+      },
+      {
+        "_path": "Library/ssl/openssl.cnf",
+        "path_type": "hardlink",
+        "sha256": "529815b0dd4bd6608bafeeb3d410b0683374e61aef792b3e3f38b3767d26f747",
+        "sha256_in_prefix": "529815b0dd4bd6608bafeeb3d410b0683374e61aef792b3e3f38b3767d26f747",
+        "size_in_bytes": 12324
+      },
+      {
+        "_path": "Library/ssl/openssl.cnf.dist",
+        "path_type": "hardlink",
+        "sha256": "529815b0dd4bd6608bafeeb3d410b0683374e61aef792b3e3f38b3767d26f747",
+        "sha256_in_prefix": "529815b0dd4bd6608bafeeb3d410b0683374e61aef792b3e3f38b3767d26f747",
+        "size_in_bytes": 12324
+      },
+      {
+        "_path": "etc/conda/activate.d/openssl_activate.bat",
+        "path_type": "hardlink",
+        "sha256": "b5ec69ff3a2abead2e4141058c056fe89696ec6ff265db3a6e12d54a7b0cf968",
+        "sha256_in_prefix": "b5ec69ff3a2abead2e4141058c056fe89696ec6ff265db3a6e12d54a7b0cf968",
+        "size_in_bytes": 141
+      },
+      {
+        "_path": "etc/conda/activate.d/openssl_activate.ps1",
+        "path_type": "hardlink",
+        "sha256": "4faf38998848de897f3d1bf343b9ed4f3357f9be924ae3f39fa878e6eac4d990",
+        "sha256_in_prefix": "4faf38998848de897f3d1bf343b9ed4f3357f9be924ae3f39fa878e6eac4d990",
+        "size_in_bytes": 146
+      },
+      {
+        "_path": "etc/conda/activate.d/openssl_activate.sh",
+        "path_type": "hardlink",
+        "sha256": "0491ca20c6a5232c054965f317e9e867306315e777b611a94a02e8cfdfb66dbe",
+        "sha256_in_prefix": "0491ca20c6a5232c054965f317e9e867306315e777b611a94a02e8cfdfb66dbe",
+        "size_in_bytes": 158
+      },
+      {
+        "_path": "etc/conda/deactivate.d/openssl_deactivate.bat",
+        "path_type": "hardlink",
+        "sha256": "66ccd7108ea8c1718f60ae81f07794f48a8c4cb3f5ab1dd2a8a17484991afdcb",
+        "sha256_in_prefix": "66ccd7108ea8c1718f60ae81f07794f48a8c4cb3f5ab1dd2a8a17484991afdcb",
+        "size_in_bytes": 120
+      },
+      {
+        "_path": "etc/conda/deactivate.d/openssl_deactivate.ps1",
+        "path_type": "hardlink",
+        "sha256": "d3c530cac4c25c2cdd70a1db5eb2078ee66c1a7e9af0b7d972fec7d22bcdc112",
+        "sha256_in_prefix": "d3c530cac4c25c2cdd70a1db5eb2078ee66c1a7e9af0b7d972fec7d22bcdc112",
+        "size_in_bytes": 150
+      },
+      {
+        "_path": "etc/conda/deactivate.d/openssl_deactivate.sh",
+        "path_type": "hardlink",
+        "sha256": "1a597cfb46c521b4dfc99ace069b32045c516421f3e83f76587871f85f29c272",
+        "sha256_in_prefix": "1a597cfb46c521b4dfc99ace069b32045c516421f3e83f76587871f85f29c272",
+        "size_in_bytes": 126
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "27941fbec3fab999105c4a26cd999318b92da39031b1b4c15872a251e436a970",
+  "size": 8195174,
+  "subdir": "win-64",
+  "timestamp": 1740991970485,
+  "track_features": "",
+  "url": "https://repo.anaconda.com/pkgs/main/win-64/openssl-3.0.16-h3f729d1_0.conda",
+  "version": "3.0.16"
+}
\ No newline at end of file
diff --git a/marketing/conda-meta/pip-25.0-py39haa95532_0.json b/marketing/conda-meta/pip-25.0-py39haa95532_0.json
new file mode 100644
index 0000000000000000000000000000000000000000..0dd42ced8bc1e5a41a198bde0b3b70818c94c860
--- /dev/null
+++ b/marketing/conda-meta/pip-25.0-py39haa95532_0.json
@@ -0,0 +1,6888 @@
+{
+  "build": "py39haa95532_0",
+  "build_number": 0,
+  "channel": "https://repo.anaconda.com/pkgs/main/win-64",
+  "constrains": [],
+  "depends": [
+    "python >=3.9,<3.10.0a0",
+    "setuptools",
+    "wheel"
+  ],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\pip-25.0-py39haa95532_0",
+  "features": "",
+  "files": [
+    "Lib/site-packages/pip-25.0.dist-info/AUTHORS.txt",
+    "Lib/site-packages/pip-25.0.dist-info/INSTALLER",
+    "Lib/site-packages/pip-25.0.dist-info/LICENSE.txt",
+    "Lib/site-packages/pip-25.0.dist-info/METADATA",
+    "Lib/site-packages/pip-25.0.dist-info/RECORD",
+    "Lib/site-packages/pip-25.0.dist-info/REQUESTED",
+    "Lib/site-packages/pip-25.0.dist-info/WHEEL",
+    "Lib/site-packages/pip-25.0.dist-info/direct_url.json",
+    "Lib/site-packages/pip-25.0.dist-info/entry_points.txt",
+    "Lib/site-packages/pip-25.0.dist-info/top_level.txt",
+    "Lib/site-packages/pip/__init__.py",
+    "Lib/site-packages/pip/__main__.py",
+    "Lib/site-packages/pip/__pip-runner__.py",
+    "Lib/site-packages/pip/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/pip/__pycache__/__pip-runner__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/__init__.py",
+    "Lib/site-packages/pip/_internal/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/__pycache__/build_env.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/__pycache__/cache.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/__pycache__/configuration.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/__pycache__/exceptions.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/__pycache__/main.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/__pycache__/pyproject.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/__pycache__/self_outdated_check.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/__pycache__/wheel_builder.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/build_env.py",
+    "Lib/site-packages/pip/_internal/cache.py",
+    "Lib/site-packages/pip/_internal/cli/__init__.py",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/autocompletion.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/base_command.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/cmdoptions.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/command_context.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/index_command.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/main.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/main_parser.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/parser.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/progress_bars.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/req_command.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/spinners.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/__pycache__/status_codes.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/cli/autocompletion.py",
+    "Lib/site-packages/pip/_internal/cli/base_command.py",
+    "Lib/site-packages/pip/_internal/cli/cmdoptions.py",
+    "Lib/site-packages/pip/_internal/cli/command_context.py",
+    "Lib/site-packages/pip/_internal/cli/index_command.py",
+    "Lib/site-packages/pip/_internal/cli/main.py",
+    "Lib/site-packages/pip/_internal/cli/main_parser.py",
+    "Lib/site-packages/pip/_internal/cli/parser.py",
+    "Lib/site-packages/pip/_internal/cli/progress_bars.py",
+    "Lib/site-packages/pip/_internal/cli/req_command.py",
+    "Lib/site-packages/pip/_internal/cli/spinners.py",
+    "Lib/site-packages/pip/_internal/cli/status_codes.py",
+    "Lib/site-packages/pip/_internal/commands/__init__.py",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/cache.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/check.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/completion.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/configuration.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/debug.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/download.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/freeze.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/hash.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/help.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/index.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/inspect.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/install.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/list.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/search.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/show.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/uninstall.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/__pycache__/wheel.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/commands/cache.py",
+    "Lib/site-packages/pip/_internal/commands/check.py",
+    "Lib/site-packages/pip/_internal/commands/completion.py",
+    "Lib/site-packages/pip/_internal/commands/configuration.py",
+    "Lib/site-packages/pip/_internal/commands/debug.py",
+    "Lib/site-packages/pip/_internal/commands/download.py",
+    "Lib/site-packages/pip/_internal/commands/freeze.py",
+    "Lib/site-packages/pip/_internal/commands/hash.py",
+    "Lib/site-packages/pip/_internal/commands/help.py",
+    "Lib/site-packages/pip/_internal/commands/index.py",
+    "Lib/site-packages/pip/_internal/commands/inspect.py",
+    "Lib/site-packages/pip/_internal/commands/install.py",
+    "Lib/site-packages/pip/_internal/commands/list.py",
+    "Lib/site-packages/pip/_internal/commands/search.py",
+    "Lib/site-packages/pip/_internal/commands/show.py",
+    "Lib/site-packages/pip/_internal/commands/uninstall.py",
+    "Lib/site-packages/pip/_internal/commands/wheel.py",
+    "Lib/site-packages/pip/_internal/configuration.py",
+    "Lib/site-packages/pip/_internal/distributions/__init__.py",
+    "Lib/site-packages/pip/_internal/distributions/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/distributions/__pycache__/base.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/distributions/__pycache__/installed.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/distributions/__pycache__/sdist.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/distributions/__pycache__/wheel.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/distributions/base.py",
+    "Lib/site-packages/pip/_internal/distributions/installed.py",
+    "Lib/site-packages/pip/_internal/distributions/sdist.py",
+    "Lib/site-packages/pip/_internal/distributions/wheel.py",
+    "Lib/site-packages/pip/_internal/exceptions.py",
+    "Lib/site-packages/pip/_internal/index/__init__.py",
+    "Lib/site-packages/pip/_internal/index/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/index/__pycache__/collector.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/index/__pycache__/package_finder.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/index/__pycache__/sources.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/index/collector.py",
+    "Lib/site-packages/pip/_internal/index/package_finder.py",
+    "Lib/site-packages/pip/_internal/index/sources.py",
+    "Lib/site-packages/pip/_internal/locations/__init__.py",
+    "Lib/site-packages/pip/_internal/locations/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/locations/__pycache__/_distutils.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/locations/__pycache__/_sysconfig.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/locations/__pycache__/base.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/locations/_distutils.py",
+    "Lib/site-packages/pip/_internal/locations/_sysconfig.py",
+    "Lib/site-packages/pip/_internal/locations/base.py",
+    "Lib/site-packages/pip/_internal/main.py",
+    "Lib/site-packages/pip/_internal/metadata/__init__.py",
+    "Lib/site-packages/pip/_internal/metadata/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/metadata/__pycache__/_json.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/metadata/__pycache__/base.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/metadata/__pycache__/pkg_resources.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/metadata/_json.py",
+    "Lib/site-packages/pip/_internal/metadata/base.py",
+    "Lib/site-packages/pip/_internal/metadata/importlib/__init__.py",
+    "Lib/site-packages/pip/_internal/metadata/importlib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/metadata/importlib/__pycache__/_compat.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/metadata/importlib/__pycache__/_dists.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/metadata/importlib/__pycache__/_envs.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/metadata/importlib/_compat.py",
+    "Lib/site-packages/pip/_internal/metadata/importlib/_dists.py",
+    "Lib/site-packages/pip/_internal/metadata/importlib/_envs.py",
+    "Lib/site-packages/pip/_internal/metadata/pkg_resources.py",
+    "Lib/site-packages/pip/_internal/models/__init__.py",
+    "Lib/site-packages/pip/_internal/models/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/candidate.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/direct_url.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/format_control.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/index.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/installation_report.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/link.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/scheme.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/search_scope.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/selection_prefs.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/target_python.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/__pycache__/wheel.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/models/candidate.py",
+    "Lib/site-packages/pip/_internal/models/direct_url.py",
+    "Lib/site-packages/pip/_internal/models/format_control.py",
+    "Lib/site-packages/pip/_internal/models/index.py",
+    "Lib/site-packages/pip/_internal/models/installation_report.py",
+    "Lib/site-packages/pip/_internal/models/link.py",
+    "Lib/site-packages/pip/_internal/models/scheme.py",
+    "Lib/site-packages/pip/_internal/models/search_scope.py",
+    "Lib/site-packages/pip/_internal/models/selection_prefs.py",
+    "Lib/site-packages/pip/_internal/models/target_python.py",
+    "Lib/site-packages/pip/_internal/models/wheel.py",
+    "Lib/site-packages/pip/_internal/network/__init__.py",
+    "Lib/site-packages/pip/_internal/network/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/network/__pycache__/auth.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/network/__pycache__/cache.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/network/__pycache__/download.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/network/__pycache__/lazy_wheel.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/network/__pycache__/session.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/network/__pycache__/utils.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/network/__pycache__/xmlrpc.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/network/auth.py",
+    "Lib/site-packages/pip/_internal/network/cache.py",
+    "Lib/site-packages/pip/_internal/network/download.py",
+    "Lib/site-packages/pip/_internal/network/lazy_wheel.py",
+    "Lib/site-packages/pip/_internal/network/session.py",
+    "Lib/site-packages/pip/_internal/network/utils.py",
+    "Lib/site-packages/pip/_internal/network/xmlrpc.py",
+    "Lib/site-packages/pip/_internal/operations/__init__.py",
+    "Lib/site-packages/pip/_internal/operations/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/__pycache__/check.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/__pycache__/freeze.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/__pycache__/prepare.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/build/__init__.py",
+    "Lib/site-packages/pip/_internal/operations/build/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/build/__pycache__/build_tracker.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/build/__pycache__/metadata.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/build/__pycache__/metadata_editable.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/build/__pycache__/wheel.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/build/__pycache__/wheel_editable.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/build/build_tracker.py",
+    "Lib/site-packages/pip/_internal/operations/build/metadata.py",
+    "Lib/site-packages/pip/_internal/operations/build/metadata_editable.py",
+    "Lib/site-packages/pip/_internal/operations/build/metadata_legacy.py",
+    "Lib/site-packages/pip/_internal/operations/build/wheel.py",
+    "Lib/site-packages/pip/_internal/operations/build/wheel_editable.py",
+    "Lib/site-packages/pip/_internal/operations/build/wheel_legacy.py",
+    "Lib/site-packages/pip/_internal/operations/check.py",
+    "Lib/site-packages/pip/_internal/operations/freeze.py",
+    "Lib/site-packages/pip/_internal/operations/install/__init__.py",
+    "Lib/site-packages/pip/_internal/operations/install/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/install/__pycache__/editable_legacy.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/install/__pycache__/wheel.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/operations/install/editable_legacy.py",
+    "Lib/site-packages/pip/_internal/operations/install/wheel.py",
+    "Lib/site-packages/pip/_internal/operations/prepare.py",
+    "Lib/site-packages/pip/_internal/pyproject.py",
+    "Lib/site-packages/pip/_internal/req/__init__.py",
+    "Lib/site-packages/pip/_internal/req/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/req/__pycache__/constructors.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/req/__pycache__/req_file.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/req/__pycache__/req_install.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/req/__pycache__/req_set.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/req/__pycache__/req_uninstall.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/req/constructors.py",
+    "Lib/site-packages/pip/_internal/req/req_file.py",
+    "Lib/site-packages/pip/_internal/req/req_install.py",
+    "Lib/site-packages/pip/_internal/req/req_set.py",
+    "Lib/site-packages/pip/_internal/req/req_uninstall.py",
+    "Lib/site-packages/pip/_internal/resolution/__init__.py",
+    "Lib/site-packages/pip/_internal/resolution/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/__pycache__/base.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/base.py",
+    "Lib/site-packages/pip/_internal/resolution/legacy/__init__.py",
+    "Lib/site-packages/pip/_internal/resolution/legacy/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/legacy/resolver.py",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__init__.py",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/base.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/base.py",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/candidates.py",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/factory.py",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/provider.py",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/reporter.py",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/requirements.py",
+    "Lib/site-packages/pip/_internal/resolution/resolvelib/resolver.py",
+    "Lib/site-packages/pip/_internal/self_outdated_check.py",
+    "Lib/site-packages/pip/_internal/utils/__init__.py",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/_jaraco_text.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/_log.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/appdirs.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/compat.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/compatibility_tags.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/datetime.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/deprecation.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/direct_url_helpers.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/egg_link.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/entrypoints.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/filesystem.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/filetypes.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/glibc.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/hashes.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/logging.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/misc.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/packaging.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/retry.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/setuptools_build.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/subprocess.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/temp_dir.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/unpacking.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/urls.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/virtualenv.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/__pycache__/wheel.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/utils/_jaraco_text.py",
+    "Lib/site-packages/pip/_internal/utils/_log.py",
+    "Lib/site-packages/pip/_internal/utils/appdirs.py",
+    "Lib/site-packages/pip/_internal/utils/compat.py",
+    "Lib/site-packages/pip/_internal/utils/compatibility_tags.py",
+    "Lib/site-packages/pip/_internal/utils/datetime.py",
+    "Lib/site-packages/pip/_internal/utils/deprecation.py",
+    "Lib/site-packages/pip/_internal/utils/direct_url_helpers.py",
+    "Lib/site-packages/pip/_internal/utils/egg_link.py",
+    "Lib/site-packages/pip/_internal/utils/entrypoints.py",
+    "Lib/site-packages/pip/_internal/utils/filesystem.py",
+    "Lib/site-packages/pip/_internal/utils/filetypes.py",
+    "Lib/site-packages/pip/_internal/utils/glibc.py",
+    "Lib/site-packages/pip/_internal/utils/hashes.py",
+    "Lib/site-packages/pip/_internal/utils/logging.py",
+    "Lib/site-packages/pip/_internal/utils/misc.py",
+    "Lib/site-packages/pip/_internal/utils/packaging.py",
+    "Lib/site-packages/pip/_internal/utils/retry.py",
+    "Lib/site-packages/pip/_internal/utils/setuptools_build.py",
+    "Lib/site-packages/pip/_internal/utils/subprocess.py",
+    "Lib/site-packages/pip/_internal/utils/temp_dir.py",
+    "Lib/site-packages/pip/_internal/utils/unpacking.py",
+    "Lib/site-packages/pip/_internal/utils/urls.py",
+    "Lib/site-packages/pip/_internal/utils/virtualenv.py",
+    "Lib/site-packages/pip/_internal/utils/wheel.py",
+    "Lib/site-packages/pip/_internal/vcs/__init__.py",
+    "Lib/site-packages/pip/_internal/vcs/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/vcs/__pycache__/bazaar.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/vcs/__pycache__/git.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/vcs/__pycache__/mercurial.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/vcs/__pycache__/subversion.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/vcs/__pycache__/versioncontrol.cpython-39.pyc",
+    "Lib/site-packages/pip/_internal/vcs/bazaar.py",
+    "Lib/site-packages/pip/_internal/vcs/git.py",
+    "Lib/site-packages/pip/_internal/vcs/mercurial.py",
+    "Lib/site-packages/pip/_internal/vcs/subversion.py",
+    "Lib/site-packages/pip/_internal/vcs/versioncontrol.py",
+    "Lib/site-packages/pip/_internal/wheel_builder.py",
+    "Lib/site-packages/pip/_vendor/__init__.py",
+    "Lib/site-packages/pip/_vendor/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__init__.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/cache.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/serialize.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/_cmd.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/adapter.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/cache.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/caches/__init__.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/controller.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/filewrapper.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/heuristics.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/py.typed",
+    "Lib/site-packages/pip/_vendor/cachecontrol/serialize.py",
+    "Lib/site-packages/pip/_vendor/cachecontrol/wrapper.py",
+    "Lib/site-packages/pip/_vendor/certifi/__init__.py",
+    "Lib/site-packages/pip/_vendor/certifi/__main__.py",
+    "Lib/site-packages/pip/_vendor/certifi/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/certifi/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/certifi/__pycache__/core.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/certifi/cacert.pem",
+    "Lib/site-packages/pip/_vendor/certifi/core.py",
+    "Lib/site-packages/pip/_vendor/certifi/py.typed",
+    "Lib/site-packages/pip/_vendor/distlib/__init__.py",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/compat.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/database.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/index.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/locators.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/manifest.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/markers.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/metadata.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/resources.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/scripts.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/util.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/version.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/__pycache__/wheel.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distlib/compat.py",
+    "Lib/site-packages/pip/_vendor/distlib/database.py",
+    "Lib/site-packages/pip/_vendor/distlib/index.py",
+    "Lib/site-packages/pip/_vendor/distlib/locators.py",
+    "Lib/site-packages/pip/_vendor/distlib/manifest.py",
+    "Lib/site-packages/pip/_vendor/distlib/markers.py",
+    "Lib/site-packages/pip/_vendor/distlib/metadata.py",
+    "Lib/site-packages/pip/_vendor/distlib/resources.py",
+    "Lib/site-packages/pip/_vendor/distlib/scripts.py",
+    "Lib/site-packages/pip/_vendor/distlib/t32.exe",
+    "Lib/site-packages/pip/_vendor/distlib/t64-arm.exe",
+    "Lib/site-packages/pip/_vendor/distlib/t64.exe",
+    "Lib/site-packages/pip/_vendor/distlib/util.py",
+    "Lib/site-packages/pip/_vendor/distlib/version.py",
+    "Lib/site-packages/pip/_vendor/distlib/w32.exe",
+    "Lib/site-packages/pip/_vendor/distlib/w64-arm.exe",
+    "Lib/site-packages/pip/_vendor/distlib/w64.exe",
+    "Lib/site-packages/pip/_vendor/distlib/wheel.py",
+    "Lib/site-packages/pip/_vendor/distro/__init__.py",
+    "Lib/site-packages/pip/_vendor/distro/__main__.py",
+    "Lib/site-packages/pip/_vendor/distro/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distro/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distro/__pycache__/distro.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/distro/distro.py",
+    "Lib/site-packages/pip/_vendor/distro/py.typed",
+    "Lib/site-packages/pip/_vendor/idna/__init__.py",
+    "Lib/site-packages/pip/_vendor/idna/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/idna/__pycache__/codec.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/idna/__pycache__/compat.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/idna/__pycache__/core.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/idna/__pycache__/intranges.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/idna/__pycache__/package_data.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/idna/codec.py",
+    "Lib/site-packages/pip/_vendor/idna/compat.py",
+    "Lib/site-packages/pip/_vendor/idna/core.py",
+    "Lib/site-packages/pip/_vendor/idna/idnadata.py",
+    "Lib/site-packages/pip/_vendor/idna/intranges.py",
+    "Lib/site-packages/pip/_vendor/idna/package_data.py",
+    "Lib/site-packages/pip/_vendor/idna/py.typed",
+    "Lib/site-packages/pip/_vendor/idna/uts46data.py",
+    "Lib/site-packages/pip/_vendor/msgpack/__init__.py",
+    "Lib/site-packages/pip/_vendor/msgpack/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/msgpack/__pycache__/exceptions.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/msgpack/__pycache__/ext.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/msgpack/__pycache__/fallback.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/msgpack/exceptions.py",
+    "Lib/site-packages/pip/_vendor/msgpack/ext.py",
+    "Lib/site-packages/pip/_vendor/msgpack/fallback.py",
+    "Lib/site-packages/pip/_vendor/packaging/__init__.py",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/_elffile.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/_manylinux.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/_musllinux.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/_parser.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/_structures.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/_tokenizer.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/markers.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/metadata.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/requirements.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/specifiers.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/tags.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/utils.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/__pycache__/version.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/_elffile.py",
+    "Lib/site-packages/pip/_vendor/packaging/_manylinux.py",
+    "Lib/site-packages/pip/_vendor/packaging/_musllinux.py",
+    "Lib/site-packages/pip/_vendor/packaging/_parser.py",
+    "Lib/site-packages/pip/_vendor/packaging/_structures.py",
+    "Lib/site-packages/pip/_vendor/packaging/_tokenizer.py",
+    "Lib/site-packages/pip/_vendor/packaging/licenses/__init__.py",
+    "Lib/site-packages/pip/_vendor/packaging/licenses/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/licenses/__pycache__/_spdx.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/packaging/licenses/_spdx.py",
+    "Lib/site-packages/pip/_vendor/packaging/markers.py",
+    "Lib/site-packages/pip/_vendor/packaging/metadata.py",
+    "Lib/site-packages/pip/_vendor/packaging/py.typed",
+    "Lib/site-packages/pip/_vendor/packaging/requirements.py",
+    "Lib/site-packages/pip/_vendor/packaging/specifiers.py",
+    "Lib/site-packages/pip/_vendor/packaging/tags.py",
+    "Lib/site-packages/pip/_vendor/packaging/utils.py",
+    "Lib/site-packages/pip/_vendor/packaging/version.py",
+    "Lib/site-packages/pip/_vendor/pkg_resources/__init__.py",
+    "Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/platformdirs/__init__.py",
+    "Lib/site-packages/pip/_vendor/platformdirs/__main__.py",
+    "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/platformdirs/android.py",
+    "Lib/site-packages/pip/_vendor/platformdirs/api.py",
+    "Lib/site-packages/pip/_vendor/platformdirs/macos.py",
+    "Lib/site-packages/pip/_vendor/platformdirs/py.typed",
+    "Lib/site-packages/pip/_vendor/platformdirs/unix.py",
+    "Lib/site-packages/pip/_vendor/platformdirs/version.py",
+    "Lib/site-packages/pip/_vendor/platformdirs/windows.py",
+    "Lib/site-packages/pip/_vendor/pygments/__init__.py",
+    "Lib/site-packages/pip/_vendor/pygments/__main__.py",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/cmdline.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/console.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/filter.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/formatter.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/lexer.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/modeline.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/plugin.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/regexopt.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/scanner.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/sphinxext.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/style.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/token.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/unistring.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/__pycache__/util.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/cmdline.py",
+    "Lib/site-packages/pip/_vendor/pygments/console.py",
+    "Lib/site-packages/pip/_vendor/pygments/filter.py",
+    "Lib/site-packages/pip/_vendor/pygments/filters/__init__.py",
+    "Lib/site-packages/pip/_vendor/pygments/filters/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatter.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__init__.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/groff.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/html.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/img.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/irc.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/latex.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/other.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/svg.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/_mapping.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/bbcode.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/groff.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/html.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/img.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/irc.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/latex.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/other.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/pangomarkup.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/rtf.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/svg.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/terminal.py",
+    "Lib/site-packages/pip/_vendor/pygments/formatters/terminal256.py",
+    "Lib/site-packages/pip/_vendor/pygments/lexer.py",
+    "Lib/site-packages/pip/_vendor/pygments/lexers/__init__.py",
+    "Lib/site-packages/pip/_vendor/pygments/lexers/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/lexers/__pycache__/_mapping.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/lexers/__pycache__/python.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/lexers/_mapping.py",
+    "Lib/site-packages/pip/_vendor/pygments/lexers/python.py",
+    "Lib/site-packages/pip/_vendor/pygments/modeline.py",
+    "Lib/site-packages/pip/_vendor/pygments/plugin.py",
+    "Lib/site-packages/pip/_vendor/pygments/regexopt.py",
+    "Lib/site-packages/pip/_vendor/pygments/scanner.py",
+    "Lib/site-packages/pip/_vendor/pygments/sphinxext.py",
+    "Lib/site-packages/pip/_vendor/pygments/style.py",
+    "Lib/site-packages/pip/_vendor/pygments/styles/__init__.py",
+    "Lib/site-packages/pip/_vendor/pygments/styles/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/styles/__pycache__/_mapping.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pygments/styles/_mapping.py",
+    "Lib/site-packages/pip/_vendor/pygments/token.py",
+    "Lib/site-packages/pip/_vendor/pygments/unistring.py",
+    "Lib/site-packages/pip/_vendor/pygments/util.py",
+    "Lib/site-packages/pip/_vendor/pyproject_hooks/__init__.py",
+    "Lib/site-packages/pip/_vendor/pyproject_hooks/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_impl.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pyproject_hooks/_impl.py",
+    "Lib/site-packages/pip/_vendor/pyproject_hooks/_in_process/__init__.py",
+    "Lib/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/_in_process.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/pyproject_hooks/_in_process/_in_process.py",
+    "Lib/site-packages/pip/_vendor/pyproject_hooks/py.typed",
+    "Lib/site-packages/pip/_vendor/requests/__init__.py",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/__version__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/_internal_utils.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/adapters.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/api.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/auth.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/certs.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/compat.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/cookies.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/exceptions.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/help.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/hooks.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/models.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/packages.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/sessions.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/status_codes.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/structures.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__pycache__/utils.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/requests/__version__.py",
+    "Lib/site-packages/pip/_vendor/requests/_internal_utils.py",
+    "Lib/site-packages/pip/_vendor/requests/adapters.py",
+    "Lib/site-packages/pip/_vendor/requests/api.py",
+    "Lib/site-packages/pip/_vendor/requests/auth.py",
+    "Lib/site-packages/pip/_vendor/requests/certs.py",
+    "Lib/site-packages/pip/_vendor/requests/compat.py",
+    "Lib/site-packages/pip/_vendor/requests/cookies.py",
+    "Lib/site-packages/pip/_vendor/requests/exceptions.py",
+    "Lib/site-packages/pip/_vendor/requests/help.py",
+    "Lib/site-packages/pip/_vendor/requests/hooks.py",
+    "Lib/site-packages/pip/_vendor/requests/models.py",
+    "Lib/site-packages/pip/_vendor/requests/packages.py",
+    "Lib/site-packages/pip/_vendor/requests/sessions.py",
+    "Lib/site-packages/pip/_vendor/requests/status_codes.py",
+    "Lib/site-packages/pip/_vendor/requests/structures.py",
+    "Lib/site-packages/pip/_vendor/requests/utils.py",
+    "Lib/site-packages/pip/_vendor/resolvelib/__init__.py",
+    "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/providers.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/reporters.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/resolvers.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/structs.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/resolvelib/compat/__init__.py",
+    "Lib/site-packages/pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py",
+    "Lib/site-packages/pip/_vendor/resolvelib/providers.py",
+    "Lib/site-packages/pip/_vendor/resolvelib/py.typed",
+    "Lib/site-packages/pip/_vendor/resolvelib/reporters.py",
+    "Lib/site-packages/pip/_vendor/resolvelib/resolvers.py",
+    "Lib/site-packages/pip/_vendor/resolvelib/structs.py",
+    "Lib/site-packages/pip/_vendor/rich/__init__.py",
+    "Lib/site-packages/pip/_vendor/rich/__main__.py",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_cell_widths.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_emoji_replace.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_export_format.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_extension.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_fileno.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_inspect.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_log_render.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_loop.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_null_file.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_palettes.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_pick.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_ratio.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_spinners.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_stack.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_timer.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_win32_console.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_windows.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_windows_renderer.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/_wrap.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/abc.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/align.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/ansi.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/bar.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/box.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/cells.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/color.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/color_triplet.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/columns.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/console.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/constrain.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/containers.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/control.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/default_styles.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/diagnose.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/emoji.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/errors.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/file_proxy.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/filesize.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/highlighter.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/json.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/jupyter.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/layout.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/live.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/live_render.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/logging.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/markup.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/measure.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/padding.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/pager.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/palette.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/panel.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/pretty.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/progress_bar.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/protocol.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/region.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/repr.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/scope.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/status.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/style.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/table.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/text.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/theme.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/themes.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/traceback.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/rich/_cell_widths.py",
+    "Lib/site-packages/pip/_vendor/rich/_emoji_codes.py",
+    "Lib/site-packages/pip/_vendor/rich/_emoji_replace.py",
+    "Lib/site-packages/pip/_vendor/rich/_export_format.py",
+    "Lib/site-packages/pip/_vendor/rich/_extension.py",
+    "Lib/site-packages/pip/_vendor/rich/_fileno.py",
+    "Lib/site-packages/pip/_vendor/rich/_inspect.py",
+    "Lib/site-packages/pip/_vendor/rich/_log_render.py",
+    "Lib/site-packages/pip/_vendor/rich/_loop.py",
+    "Lib/site-packages/pip/_vendor/rich/_null_file.py",
+    "Lib/site-packages/pip/_vendor/rich/_palettes.py",
+    "Lib/site-packages/pip/_vendor/rich/_pick.py",
+    "Lib/site-packages/pip/_vendor/rich/_ratio.py",
+    "Lib/site-packages/pip/_vendor/rich/_spinners.py",
+    "Lib/site-packages/pip/_vendor/rich/_stack.py",
+    "Lib/site-packages/pip/_vendor/rich/_timer.py",
+    "Lib/site-packages/pip/_vendor/rich/_win32_console.py",
+    "Lib/site-packages/pip/_vendor/rich/_windows.py",
+    "Lib/site-packages/pip/_vendor/rich/_windows_renderer.py",
+    "Lib/site-packages/pip/_vendor/rich/_wrap.py",
+    "Lib/site-packages/pip/_vendor/rich/abc.py",
+    "Lib/site-packages/pip/_vendor/rich/align.py",
+    "Lib/site-packages/pip/_vendor/rich/ansi.py",
+    "Lib/site-packages/pip/_vendor/rich/bar.py",
+    "Lib/site-packages/pip/_vendor/rich/box.py",
+    "Lib/site-packages/pip/_vendor/rich/cells.py",
+    "Lib/site-packages/pip/_vendor/rich/color.py",
+    "Lib/site-packages/pip/_vendor/rich/color_triplet.py",
+    "Lib/site-packages/pip/_vendor/rich/columns.py",
+    "Lib/site-packages/pip/_vendor/rich/console.py",
+    "Lib/site-packages/pip/_vendor/rich/constrain.py",
+    "Lib/site-packages/pip/_vendor/rich/containers.py",
+    "Lib/site-packages/pip/_vendor/rich/control.py",
+    "Lib/site-packages/pip/_vendor/rich/default_styles.py",
+    "Lib/site-packages/pip/_vendor/rich/diagnose.py",
+    "Lib/site-packages/pip/_vendor/rich/emoji.py",
+    "Lib/site-packages/pip/_vendor/rich/errors.py",
+    "Lib/site-packages/pip/_vendor/rich/file_proxy.py",
+    "Lib/site-packages/pip/_vendor/rich/filesize.py",
+    "Lib/site-packages/pip/_vendor/rich/highlighter.py",
+    "Lib/site-packages/pip/_vendor/rich/json.py",
+    "Lib/site-packages/pip/_vendor/rich/jupyter.py",
+    "Lib/site-packages/pip/_vendor/rich/layout.py",
+    "Lib/site-packages/pip/_vendor/rich/live.py",
+    "Lib/site-packages/pip/_vendor/rich/live_render.py",
+    "Lib/site-packages/pip/_vendor/rich/logging.py",
+    "Lib/site-packages/pip/_vendor/rich/markup.py",
+    "Lib/site-packages/pip/_vendor/rich/measure.py",
+    "Lib/site-packages/pip/_vendor/rich/padding.py",
+    "Lib/site-packages/pip/_vendor/rich/pager.py",
+    "Lib/site-packages/pip/_vendor/rich/palette.py",
+    "Lib/site-packages/pip/_vendor/rich/panel.py",
+    "Lib/site-packages/pip/_vendor/rich/pretty.py",
+    "Lib/site-packages/pip/_vendor/rich/progress.py",
+    "Lib/site-packages/pip/_vendor/rich/progress_bar.py",
+    "Lib/site-packages/pip/_vendor/rich/prompt.py",
+    "Lib/site-packages/pip/_vendor/rich/protocol.py",
+    "Lib/site-packages/pip/_vendor/rich/py.typed",
+    "Lib/site-packages/pip/_vendor/rich/region.py",
+    "Lib/site-packages/pip/_vendor/rich/repr.py",
+    "Lib/site-packages/pip/_vendor/rich/rule.py",
+    "Lib/site-packages/pip/_vendor/rich/scope.py",
+    "Lib/site-packages/pip/_vendor/rich/screen.py",
+    "Lib/site-packages/pip/_vendor/rich/segment.py",
+    "Lib/site-packages/pip/_vendor/rich/spinner.py",
+    "Lib/site-packages/pip/_vendor/rich/status.py",
+    "Lib/site-packages/pip/_vendor/rich/style.py",
+    "Lib/site-packages/pip/_vendor/rich/styled.py",
+    "Lib/site-packages/pip/_vendor/rich/syntax.py",
+    "Lib/site-packages/pip/_vendor/rich/table.py",
+    "Lib/site-packages/pip/_vendor/rich/terminal_theme.py",
+    "Lib/site-packages/pip/_vendor/rich/text.py",
+    "Lib/site-packages/pip/_vendor/rich/theme.py",
+    "Lib/site-packages/pip/_vendor/rich/themes.py",
+    "Lib/site-packages/pip/_vendor/rich/traceback.py",
+    "Lib/site-packages/pip/_vendor/rich/tree.py",
+    "Lib/site-packages/pip/_vendor/tomli/__init__.py",
+    "Lib/site-packages/pip/_vendor/tomli/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/tomli/__pycache__/_parser.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/tomli/__pycache__/_re.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/tomli/__pycache__/_types.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/tomli/_parser.py",
+    "Lib/site-packages/pip/_vendor/tomli/_re.py",
+    "Lib/site-packages/pip/_vendor/tomli/_types.py",
+    "Lib/site-packages/pip/_vendor/tomli/py.typed",
+    "Lib/site-packages/pip/_vendor/truststore/__init__.py",
+    "Lib/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/truststore/__pycache__/_api.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/truststore/__pycache__/_macos.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/truststore/__pycache__/_openssl.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/truststore/__pycache__/_windows.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/truststore/_api.py",
+    "Lib/site-packages/pip/_vendor/truststore/_macos.py",
+    "Lib/site-packages/pip/_vendor/truststore/_openssl.py",
+    "Lib/site-packages/pip/_vendor/truststore/_ssl_constants.py",
+    "Lib/site-packages/pip/_vendor/truststore/_windows.py",
+    "Lib/site-packages/pip/_vendor/truststore/py.typed",
+    "Lib/site-packages/pip/_vendor/typing_extensions.py",
+    "Lib/site-packages/pip/_vendor/urllib3/__init__.py",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/_collections.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/_version.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/connection.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/connectionpool.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/exceptions.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/fields.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/filepost.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/poolmanager.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/request.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/__pycache__/response.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/_collections.py",
+    "Lib/site-packages/pip/_vendor/urllib3/_version.py",
+    "Lib/site-packages/pip/_vendor/urllib3/connection.py",
+    "Lib/site-packages/pip/_vendor/urllib3/connectionpool.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/__init__.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/appengine.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/securetransport.py",
+    "Lib/site-packages/pip/_vendor/urllib3/contrib/socks.py",
+    "Lib/site-packages/pip/_vendor/urllib3/exceptions.py",
+    "Lib/site-packages/pip/_vendor/urllib3/fields.py",
+    "Lib/site-packages/pip/_vendor/urllib3/filepost.py",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/__init__.py",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/__pycache__/six.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/backports/weakref_finalize.py",
+    "Lib/site-packages/pip/_vendor/urllib3/packages/six.py",
+    "Lib/site-packages/pip/_vendor/urllib3/poolmanager.py",
+    "Lib/site-packages/pip/_vendor/urllib3/request.py",
+    "Lib/site-packages/pip/_vendor/urllib3/response.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__init__.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/connection.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/proxy.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/queue.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/request.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/response.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/retry.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/timeout.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/url.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/wait.cpython-39.pyc",
+    "Lib/site-packages/pip/_vendor/urllib3/util/connection.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/proxy.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/queue.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/request.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/response.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/retry.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/ssl_.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/ssl_match_hostname.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/ssltransport.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/timeout.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/url.py",
+    "Lib/site-packages/pip/_vendor/urllib3/util/wait.py",
+    "Lib/site-packages/pip/_vendor/vendor.txt",
+    "Lib/site-packages/pip/py.typed",
+    "Scripts/pip-script.py",
+    "Scripts/pip.exe",
+    "Scripts/pip3-script.py",
+    "Scripts/pip3.exe",
+    ".nonadmin"
+  ],
+  "fn": "pip-25.0-py39haa95532_0.conda",
+  "legacy_bz2_md5": "66dc735e4ccc1b3aab8bbad43d5d927f",
+  "license": "MIT",
+  "license_family": "MIT",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\pip-25.0-py39haa95532_0",
+    "type": 1
+  },
+  "md5": "a894b6df702250d5c246a518523f07af",
+  "name": "pip",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\pip-25.0-py39haa95532_0.conda",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/AUTHORS.txt",
+        "path_type": "hardlink",
+        "sha256": "1eace90552df4f5941b61a907e20e555e16483ae6127b650bef5a1a2af8102c0",
+        "sha256_in_prefix": "1eace90552df4f5941b61a907e20e555e16483ae6127b650bef5a1a2af8102c0",
+        "size_in_bytes": 11018
+      },
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/LICENSE.txt",
+        "path_type": "hardlink",
+        "sha256": "634300a669d49aeae65b12c6c48c924c51a4cdf3d1ff086dc3456dc8bcaa2104",
+        "sha256_in_prefix": "634300a669d49aeae65b12c6c48c924c51a4cdf3d1ff086dc3456dc8bcaa2104",
+        "size_in_bytes": 1093
+      },
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "e861c238e756013519abf1a831e7468fd1471de3a203aa94cb7303f28f1b4c13",
+        "sha256_in_prefix": "e861c238e756013519abf1a831e7468fd1471de3a203aa94cb7303f28f1b4c13",
+        "size_in_bytes": 3765
+      },
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "92c1b25b169dd206874ce729784f66805078140a24e74832839df2c96b61bce6",
+        "sha256_in_prefix": "92c1b25b169dd206874ce729784f66805078140a24e74832839df2c96b61bce6",
+        "size_in_bytes": 65400
+      },
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "195f5a3138703ffe28342b6f102d9e737a9462eb6059e033925ae8ff49b85894",
+        "sha256_in_prefix": "195f5a3138703ffe28342b6f102d9e737a9462eb6059e033925ae8ff49b85894",
+        "size_in_bytes": 91
+      },
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/direct_url.json",
+        "path_type": "hardlink",
+        "sha256": "f74a961219c3f9c59bed705c8bfb197be56c34c49b1b33bbb75ab9f558b62873",
+        "sha256_in_prefix": "f74a961219c3f9c59bed705c8bfb197be56c34c49b1b33bbb75ab9f558b62873",
+        "size_in_bytes": 83
+      },
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/entry_points.txt",
+        "path_type": "hardlink",
+        "sha256": "79e223bb37e77d1d8fae16e39dbcc553a327492ef49192f1c1a1c7aba33e6c3d",
+        "sha256_in_prefix": "79e223bb37e77d1d8fae16e39dbcc553a327492ef49192f1c1a1c7aba33e6c3d",
+        "size_in_bytes": 87
+      },
+      {
+        "_path": "Lib/site-packages/pip-25.0.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "ceebae7b8927a3227e5303cf5e0f1f7b34bb542ad7250ac03fbcde36ec2f1508",
+        "sha256_in_prefix": "ceebae7b8927a3227e5303cf5e0f1f7b34bb542ad7250ac03fbcde36ec2f1508",
+        "size_in_bytes": 4
+      },
+      {
+        "_path": "Lib/site-packages/pip/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "fcdfe116bb0495891ca68d770fd3712f00f33c5dd6824497a6fe058caa126bff",
+        "sha256_in_prefix": "fcdfe116bb0495891ca68d770fd3712f00f33c5dd6824497a6fe058caa126bff",
+        "size_in_bytes": 355
+      },
+      {
+        "_path": "Lib/site-packages/pip/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "5b36e11d74db484ea0058d7d98d37d9b8b39a3fdfae4b3af4d84a0aa06dd0611",
+        "sha256_in_prefix": "5b36e11d74db484ea0058d7d98d37d9b8b39a3fdfae4b3af4d84a0aa06dd0611",
+        "size_in_bytes": 854
+      },
+      {
+        "_path": "Lib/site-packages/pip/__pip-runner__.py",
+        "path_type": "hardlink",
+        "sha256": "70f3d6b89e8d2bf93e1b37ef95e8cb160c339985113a6a4047a402dd0faf9174",
+        "sha256_in_prefix": "70f3d6b89e8d2bf93e1b37ef95e8cb160c339985113a6a4047a402dd0faf9174",
+        "size_in_bytes": 1450
+      },
+      {
+        "_path": "Lib/site-packages/pip/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8790f05ef47a1aad313978dfbed67987c709125033d093a9efee140062afe746",
+        "sha256_in_prefix": "8790f05ef47a1aad313978dfbed67987c709125033d093a9efee140062afe746",
+        "size_in_bytes": 578
+      },
+      {
+        "_path": "Lib/site-packages/pip/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dcc6db86cff0df0915c1afbf0e771d105a481e561044252d1e0529419b4849ad",
+        "sha256_in_prefix": "dcc6db86cff0df0915c1afbf0e771d105a481e561044252d1e0529419b4849ad",
+        "size_in_bytes": 408
+      },
+      {
+        "_path": "Lib/site-packages/pip/__pycache__/__pip-runner__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aef7d5db37bb6aa204b6df4542c2cba485a5759ce3f453c39772d75e71d77762",
+        "sha256_in_prefix": "aef7d5db37bb6aa204b6df4542c2cba485a5759ce3f453c39772d75e71d77762",
+        "size_in_bytes": 1570
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "31f7283a5b8367c40c08561a974e08a8e27daba9b657b6b468eb2723e58ec54a",
+        "sha256_in_prefix": "31f7283a5b8367c40c08561a974e08a8e27daba9b657b6b468eb2723e58ec54a",
+        "size_in_bytes": 513
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "816e3cdb0dee644f0bc3fe1ae4225df2f3d0a9b1794f4fc6dcd2af715606e942",
+        "sha256_in_prefix": "816e3cdb0dee644f0bc3fe1ae4225df2f3d0a9b1794f4fc6dcd2af715606e942",
+        "size_in_bytes": 642
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__pycache__/build_env.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0cefe50559b9c9bdb1b4893244c143c2cf6eb529ec5eb1cd084ee18b841e9f31",
+        "sha256_in_prefix": "0cefe50559b9c9bdb1b4893244c143c2cf6eb529ec5eb1cd084ee18b841e9f31",
+        "size_in_bytes": 9824
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__pycache__/cache.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0200a3e3e8cc40cb587ddee3ef6d77113ff95d01721157405a94fbe3bbb90e09",
+        "sha256_in_prefix": "0200a3e3e8cc40cb587ddee3ef6d77113ff95d01721157405a94fbe3bbb90e09",
+        "size_in_bytes": 8938
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__pycache__/configuration.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7858e2b3df82e390fc49a7551ad606d230b85e398e1426a0246b9b6f8dfea1a8",
+        "sha256_in_prefix": "7858e2b3df82e390fc49a7551ad606d230b85e398e1426a0246b9b6f8dfea1a8",
+        "size_in_bytes": 11633
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__pycache__/exceptions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "65b1117e222129ea2916e21fe0f31065d7263a786f321d82629dd4bf8f6483c7",
+        "sha256_in_prefix": "65b1117e222129ea2916e21fe0f31065d7263a786f321d82629dd4bf8f6483c7",
+        "size_in_bytes": 28293
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__pycache__/main.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "98a3f1be9f3ad8a7409e43344108a46218f931c4c68532ac8487bbca37409dce",
+        "sha256_in_prefix": "98a3f1be9f3ad8a7409e43344108a46218f931c4c68532ac8487bbca37409dce",
+        "size_in_bytes": 566
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__pycache__/pyproject.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f0b80734f4cd257e6c2e15ca12fd206e3aa7fbdaa717f3a1317b00b112216e66",
+        "sha256_in_prefix": "f0b80734f4cd257e6c2e15ca12fd206e3aa7fbdaa717f3a1317b00b112216e66",
+        "size_in_bytes": 3719
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__pycache__/self_outdated_check.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2368ba911586548e4352180aed85505d48edc9c2416a65761d3eaf2fbb52adad",
+        "sha256_in_prefix": "2368ba911586548e4352180aed85505d48edc9c2416a65761d3eaf2fbb52adad",
+        "size_in_bytes": 6792
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/__pycache__/wheel_builder.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "05ef72f2f1a393e696e9704ba3de114c45525de408095812ecf83eb35b552ecd",
+        "sha256_in_prefix": "05ef72f2f1a393e696e9704ba3de114c45525de408095812ecf83eb35b552ecd",
+        "size_in_bytes": 8610
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/build_env.py",
+        "path_type": "hardlink",
+        "sha256": "1419d13f0b14948d39235497a18b2afd96ded5db243e90926d2e2c9ae548fcea",
+        "sha256_in_prefix": "1419d13f0b14948d39235497a18b2afd96ded5db243e90926d2e2c9ae548fcea",
+        "size_in_bytes": 10716
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cache.py",
+        "path_type": "hardlink",
+        "sha256": "25bebdf29e4f362811b695b9a36eb040d92452fe0c9d0f7899ce3bd702fadc0d",
+        "sha256_in_prefix": "25bebdf29e4f362811b695b9a36eb040d92452fe0c9d0f7899ce3bd702fadc0d",
+        "size_in_bytes": 10369
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "1641c1829c716fefe077aaf51639cd85f30ecc0518c97a17289e9a6e28df7055",
+        "sha256_in_prefix": "1641c1829c716fefe077aaf51639cd85f30ecc0518c97a17289e9a6e28df7055",
+        "size_in_bytes": 132
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eaa64eccf9a5bb8342b0891cae8028c4c1fa578366590dbfef4e643bf9b2a89f",
+        "sha256_in_prefix": "eaa64eccf9a5bb8342b0891cae8028c4c1fa578366590dbfef4e643bf9b2a89f",
+        "size_in_bytes": 221
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/autocompletion.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "211c224f523b207d2bbaeda8b4845405623af027e24eb852c4d96370a9f5a797",
+        "sha256_in_prefix": "211c224f523b207d2bbaeda8b4845405623af027e24eb852c4d96370a9f5a797",
+        "size_in_bytes": 5338
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/base_command.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a4cf44b30d4d84167e385a990e4202d561d7cdf58705f9e831af49964b9af183",
+        "sha256_in_prefix": "a4cf44b30d4d84167e385a990e4202d561d7cdf58705f9e831af49964b9af183",
+        "size_in_bytes": 6576
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/cmdoptions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2bf870a193629dc416be7d91fde4ec060255551b578335d7ac6e638c3570503f",
+        "sha256_in_prefix": "2bf870a193629dc416be7d91fde4ec060255551b578335d7ac6e638c3570503f",
+        "size_in_bytes": 23608
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/command_context.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2f8928a6e3188bd0144221207024a5efb44e46dbf936b39612bf3b21464379e7",
+        "sha256_in_prefix": "2f8928a6e3188bd0144221207024a5efb44e46dbf936b39612bf3b21464379e7",
+        "size_in_bytes": 1242
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/index_command.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd5807bf011e3d134a82fecab1aa7bb756d5b7b4963494d203abecd91f4898af",
+        "sha256_in_prefix": "dd5807bf011e3d134a82fecab1aa7bb756d5b7b4963494d203abecd91f4898af",
+        "size_in_bytes": 4887
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/main.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e00162760683e5e4eb23cfb73d0bbd46cea9466c04e9b45bdbf4c4a95858c00f",
+        "sha256_in_prefix": "e00162760683e5e4eb23cfb73d0bbd46cea9466c04e9b45bdbf4c4a95858c00f",
+        "size_in_bytes": 1447
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/main_parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3e399454eb09b9b01e4a3b6d1cfd6d237a701ea68dec3bed3c52be358ca725c3",
+        "sha256_in_prefix": "3e399454eb09b9b01e4a3b6d1cfd6d237a701ea68dec3bed3c52be358ca725c3",
+        "size_in_bytes": 2964
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6d2229b4400e39cfb98325d67f9e39b02d56e4be02068220b7e6cb434ffa26fd",
+        "sha256_in_prefix": "6d2229b4400e39cfb98325d67f9e39b02d56e4be02068220b7e6cb434ffa26fd",
+        "size_in_bytes": 9920
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/progress_bars.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c5af7c36990245cf06ec5ec0601ca8d1230cf7346399cb2ceb065fdd788cf287",
+        "sha256_in_prefix": "c5af7c36990245cf06ec5ec0601ca8d1230cf7346399cb2ceb065fdd788cf287",
+        "size_in_bytes": 2573
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/req_command.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4bf56649b1bc9ddb697905c2971ae1fa4cd3864fec097e4a0a398536228752e7",
+        "sha256_in_prefix": "4bf56649b1bc9ddb697905c2971ae1fa4cd3864fec097e4a0a398536228752e7",
+        "size_in_bytes": 8593
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/spinners.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d9bfa3b23af1481ebee477afd3ea4d8229a423b43cbe82e99a79003fb075e1af",
+        "sha256_in_prefix": "d9bfa3b23af1481ebee477afd3ea4d8229a423b43cbe82e99a79003fb075e1af",
+        "size_in_bytes": 4907
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/__pycache__/status_codes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bebfac01e74c623ac9928ef455692f45daee7f9d22a1be202d27922abba4b862",
+        "sha256_in_prefix": "bebfac01e74c623ac9928ef455692f45daee7f9d22a1be202d27922abba4b862",
+        "size_in_bytes": 300
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/autocompletion.py",
+        "path_type": "hardlink",
+        "sha256": "2e58b732be9a0cdbbb664249145bf00f6fa1171348e80bf3f0ec0cc92e5356bb",
+        "sha256_in_prefix": "2e58b732be9a0cdbbb664249145bf00f6fa1171348e80bf3f0ec0cc92e5356bb",
+        "size_in_bytes": 6865
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/base_command.py",
+        "path_type": "hardlink",
+        "sha256": "3598a7e8a3335bd3526332a4e1373c8ac6ff4d060a47808a7798fd9929b8e8f2",
+        "sha256_in_prefix": "3598a7e8a3335bd3526332a4e1373c8ac6ff4d060a47808a7798fd9929b8e8f2",
+        "size_in_bytes": 8625
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/cmdoptions.py",
+        "path_type": "hardlink",
+        "sha256": "577041db6178feffd1907699e689d69ecce16c1b63619bcd85b9fd33434ed072",
+        "sha256_in_prefix": "577041db6178feffd1907699e689d69ecce16c1b63619bcd85b9fd33434ed072",
+        "size_in_bytes": 30116
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/command_context.py",
+        "path_type": "hardlink",
+        "sha256": "4478083f0b4e6e1e4a84cadddd8653925f336d51bee8e92697b61b157e04860d",
+        "sha256_in_prefix": "4478083f0b4e6e1e4a84cadddd8653925f336d51bee8e92697b61b157e04860d",
+        "size_in_bytes": 774
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/index_command.py",
+        "path_type": "hardlink",
+        "sha256": "8bfb203653e65c2e621d4698f9d9a6ac728a4e07393b8856ce2b2be40975aebd",
+        "sha256_in_prefix": "8bfb203653e65c2e621d4698f9d9a6ac728a4e07393b8856ce2b2be40975aebd",
+        "size_in_bytes": 5677
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/main.py",
+        "path_type": "hardlink",
+        "sha256": "04365e7fe6d67bd83d269af8395b387437fef38e4726c2b0f37e53ec0a849c07",
+        "sha256_in_prefix": "04365e7fe6d67bd83d269af8395b387437fef38e4726c2b0f37e53ec0a849c07",
+        "size_in_bytes": 2817
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/main_parser.py",
+        "path_type": "hardlink",
+        "sha256": "95a0e9b2e04397a9327f2c29f5e30c03db3ce237c7d932499febe62f4186f74c",
+        "sha256_in_prefix": "95a0e9b2e04397a9327f2c29f5e30c03db3ce237c7d932499febe62f4186f74c",
+        "size_in_bytes": 4338
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/parser.py",
+        "path_type": "hardlink",
+        "sha256": "54232d76ecc409457ceca68736efb127ec0b34bf36c93df1d7a5785c1c4e02a2",
+        "sha256_in_prefix": "54232d76ecc409457ceca68736efb127ec0b34bf36c93df1d7a5785c1c4e02a2",
+        "size_in_bytes": 10825
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/progress_bars.py",
+        "path_type": "hardlink",
+        "sha256": "f46720bac5adc1faa8bb6ce1010a755cd6d01c80ec96acb2cfd5302f3c3b2607",
+        "sha256_in_prefix": "f46720bac5adc1faa8bb6ce1010a755cd6d01c80ec96acb2cfd5302f3c3b2607",
+        "size_in_bytes": 2717
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/req_command.py",
+        "path_type": "hardlink",
+        "sha256": "0ea78586650cb3aa3a12ff2a6b001c3a860d74066c7f2292d0c648e63b096304",
+        "sha256_in_prefix": "0ea78586650cb3aa3a12ff2a6b001c3a860d74066c7f2292d0c648e63b096304",
+        "size_in_bytes": 12250
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/spinners.py",
+        "path_type": "hardlink",
+        "sha256": "84827cdc67ab74580509da1b200db726081eb5e825fee0b84a9e7cea7cc56cf1",
+        "sha256_in_prefix": "84827cdc67ab74580509da1b200db726081eb5e825fee0b84a9e7cea7cc56cf1",
+        "size_in_bytes": 5118
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/cli/status_codes.py",
+        "path_type": "hardlink",
+        "sha256": "b0414751a5096eabfc880acbdc702d733b5666618e157d358537ac4b2b43121d",
+        "sha256_in_prefix": "b0414751a5096eabfc880acbdc702d733b5666618e157d358537ac4b2b43121d",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e6844ef4eddd336bc6ba1d1b170e0739595eb6bcabcf91c732698f5b026b1fd5",
+        "sha256_in_prefix": "e6844ef4eddd336bc6ba1d1b170e0739595eb6bcabcf91c732698f5b026b1fd5",
+        "size_in_bytes": 3882
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "73ad42dd71bbf633584314a6e7b2e3d2db67c46f02ffb48558e970fcbfe511a1",
+        "sha256_in_prefix": "73ad42dd71bbf633584314a6e7b2e3d2db67c46f02ffb48558e970fcbfe511a1",
+        "size_in_bytes": 3108
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/cache.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5d593356805b900efc2a7f171194fa0283f0665d1b652c678957a1aec2090ef8",
+        "sha256_in_prefix": "5d593356805b900efc2a7f171194fa0283f0665d1b652c678957a1aec2090ef8",
+        "size_in_bytes": 6487
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/check.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4983f66142f84b742299332ebbb12d99198d4d2edcf6d4c364d9539a887b912c",
+        "sha256_in_prefix": "4983f66142f84b742299332ebbb12d99198d4d2edcf6d4c364d9539a887b912c",
+        "size_in_bytes": 1916
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/completion.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a25b063f1b6b5c3d30ac2e27b670ab0c5a64bf02f013e7c5e52f36bb36149a6a",
+        "sha256_in_prefix": "a25b063f1b6b5c3d30ac2e27b670ab0c5a64bf02f013e7c5e52f36bb36149a6a",
+        "size_in_bytes": 4269
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/configuration.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d3e1f19492f7394cf160baf536ba1efbfb5fc4170ad2ad40236e506955b965f1",
+        "sha256_in_prefix": "d3e1f19492f7394cf160baf536ba1efbfb5fc4170ad2ad40236e506955b965f1",
+        "size_in_bytes": 8895
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/debug.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7425e572f6e31aeed606366c49bc44b05c4310f801b76950db3b3b3d05a897ae",
+        "sha256_in_prefix": "7425e572f6e31aeed606366c49bc44b05c4310f801b76950db3b3b3d05a897ae",
+        "size_in_bytes": 6816
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/download.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "12baefa3c6a0f3dfd17e9a61a0f0644615f081d971e499b7affd2c52791b5608",
+        "sha256_in_prefix": "12baefa3c6a0f3dfd17e9a61a0f0644615f081d971e499b7affd2c52791b5608",
+        "size_in_bytes": 4148
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/freeze.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f14278b2194b6c32a5c21debbe6c77d3627e6e7be30dda2a089eb9e9e5f275ce",
+        "sha256_in_prefix": "f14278b2194b6c32a5c21debbe6c77d3627e6e7be30dda2a089eb9e9e5f275ce",
+        "size_in_bytes": 2949
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/hash.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "be275a3854aef3d84aee0a73a54df28dd913637c67f1f86a2d578f73079ccab6",
+        "sha256_in_prefix": "be275a3854aef3d84aee0a73a54df28dd913637c67f1f86a2d578f73079ccab6",
+        "size_in_bytes": 2080
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/help.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fb87646faa51e0716163393125889116366c7f3b777b04abb84d5e9da85cbff7",
+        "sha256_in_prefix": "fb87646faa51e0716163393125889116366c7f3b777b04abb84d5e9da85cbff7",
+        "size_in_bytes": 1252
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/index.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8e164df3d362231789f51d66008c330e01c6b7ed7f791a7ff6416fe153b72cb8",
+        "sha256_in_prefix": "8e164df3d362231789f51d66008c330e01c6b7ed7f791a7ff6416fe153b72cb8",
+        "size_in_bytes": 4456
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/inspect.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a1413b9656376b058675b32829b04f3c3184e06bb1e088f6eac9c823ad0b2ad7",
+        "sha256_in_prefix": "a1413b9656376b058675b32829b04f3c3184e06bb1e088f6eac9c823ad0b2ad7",
+        "size_in_bytes": 2921
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7a95623cc496c418e2f81ff98c45d36aafebb7667d82fd043027c45b62976320",
+        "sha256_in_prefix": "7a95623cc496c418e2f81ff98c45d36aafebb7667d82fd043027c45b62976320",
+        "size_in_bytes": 17747
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/list.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "af366ac81991ee0d40105d61945dfadca9267af9aae491aa249e844f07ad6876",
+        "sha256_in_prefix": "af366ac81991ee0d40105d61945dfadca9267af9aae491aa249e844f07ad6876",
+        "size_in_bytes": 10493
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/search.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "524cfd1cf0c4b976cc8989ec4bef4fdb1ca3baf6fd0ac0111c356d1825663684",
+        "sha256_in_prefix": "524cfd1cf0c4b976cc8989ec4bef4fdb1ca3baf6fd0ac0111c356d1825663684",
+        "size_in_bytes": 5220
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/show.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7f1285b56e1446c990efac1e02fe3a2ec513f2ad97a78c9f93c52aa2cf20646d",
+        "sha256_in_prefix": "7f1285b56e1446c990efac1e02fe3a2ec513f2ad97a78c9f93c52aa2cf20646d",
+        "size_in_bytes": 6989
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/uninstall.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "953c7307b0a49eb3827ebe058e8418c1eae542bf76363b72147b2e36fe538cbe",
+        "sha256_in_prefix": "953c7307b0a49eb3827ebe058e8418c1eae542bf76363b72147b2e36fe538cbe",
+        "size_in_bytes": 3276
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/__pycache__/wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0e12691f0d83dc5cea54d9e43fd5ba7b21a867ce5683611879ba9924d7f421be",
+        "sha256_in_prefix": "0e12691f0d83dc5cea54d9e43fd5ba7b21a867ce5683611879ba9924d7f421be",
+        "size_in_bytes": 4889
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/cache.py",
+        "path_type": "hardlink",
+        "sha256": "20e7b34e27078c6139b16741c769f03d581b8ee247337b3e059124a592de9ae6",
+        "sha256_in_prefix": "20e7b34e27078c6139b16741c769f03d581b8ee247337b3e059124a592de9ae6",
+        "size_in_bytes": 8107
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/check.py",
+        "path_type": "hardlink",
+        "sha256": "1ebff87a231df5c8150e012f8ed21dc3dd793662fb44e2165bc7a792bf2c94f4",
+        "sha256_in_prefix": "1ebff87a231df5c8150e012f8ed21dc3dd793662fb44e2165bc7a792bf2c94f4",
+        "size_in_bytes": 2268
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/completion.py",
+        "path_type": "hardlink",
+        "sha256": "1d3e250f46e0b1f947ab62038187e211da7b2061ad13bb3a320237c67d15404c",
+        "sha256_in_prefix": "1d3e250f46e0b1f947ab62038187e211da7b2061ad13bb3a320237c67d15404c",
+        "size_in_bytes": 4287
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/configuration.py",
+        "path_type": "hardlink",
+        "sha256": "9fdf1e9f0a7acb46f91ba7e24508da668e3716524a62f7bf75a32137ee0144d7",
+        "sha256_in_prefix": "9fdf1e9f0a7acb46f91ba7e24508da668e3716524a62f7bf75a32137ee0144d7",
+        "size_in_bytes": 9766
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/debug.py",
+        "path_type": "hardlink",
+        "sha256": "0cd0d1804f58b0aadb633534b3754a8bcac7b4a1785f5dc227f6ebffc3d45ced",
+        "sha256_in_prefix": "0cd0d1804f58b0aadb633534b3754a8bcac7b4a1785f5dc227f6ebffc3d45ced",
+        "size_in_bytes": 6797
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/download.py",
+        "path_type": "hardlink",
+        "sha256": "d2a0749f2b3a6443eca20e39d650ec8cbe41c7b67deedf81f34a0564a869cca3",
+        "sha256_in_prefix": "d2a0749f2b3a6443eca20e39d650ec8cbe41c7b67deedf81f34a0564a869cca3",
+        "size_in_bytes": 5273
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/freeze.py",
+        "path_type": "hardlink",
+        "sha256": "d95b7bd816134a6f6bcee7ba77c74dcedf2277158ae036fa1ddf9a9eaec643cd",
+        "sha256_in_prefix": "d95b7bd816134a6f6bcee7ba77c74dcedf2277158ae036fa1ddf9a9eaec643cd",
+        "size_in_bytes": 3203
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/hash.py",
+        "path_type": "hardlink",
+        "sha256": "11554ebaf1ada0f11d162f1236799daa5090ae10b157e909b1dc2d75c0a75c64",
+        "sha256_in_prefix": "11554ebaf1ada0f11d162f1236799daa5090ae10b157e909b1dc2d75c0a75c64",
+        "size_in_bytes": 1703
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/help.py",
+        "path_type": "hardlink",
+        "sha256": "81c73a40391c80730eb809f9531699c004adb1106b9c64a7ff2c634b9ec92283",
+        "sha256_in_prefix": "81c73a40391c80730eb809f9531699c004adb1106b9c64a7ff2c634b9ec92283",
+        "size_in_bytes": 1132
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/index.py",
+        "path_type": "hardlink",
+        "sha256": "4405f1989c058556f94b5058cdbe627d7dec9fd35af2fd8209563048c3fca5aa",
+        "sha256_in_prefix": "4405f1989c058556f94b5058cdbe627d7dec9fd35af2fd8209563048c3fca5aa",
+        "size_in_bytes": 4731
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/inspect.py",
+        "path_type": "hardlink",
+        "sha256": "3c6ad8f53453442337cb9325f01764f0310e5eab9645fb1caf80d1a352ce4cf7",
+        "sha256_in_prefix": "3c6ad8f53453442337cb9325f01764f0310e5eab9645fb1caf80d1a352ce4cf7",
+        "size_in_bytes": 3189
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/install.py",
+        "path_type": "hardlink",
+        "sha256": "af7c87414c6fc6dee00f98fd9facd10ec940bedc7d093ff084bb9025c92da7a3",
+        "sha256_in_prefix": "af7c87414c6fc6dee00f98fd9facd10ec940bedc7d093ff084bb9025c92da7a3",
+        "size_in_bytes": 29390
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/list.py",
+        "path_type": "hardlink",
+        "sha256": "a222334a32cfebffddedd212dead176f9cb0b1a393841591a8cca38cace43dd3",
+        "sha256_in_prefix": "a222334a32cfebffddedd212dead176f9cb0b1a393841591a8cca38cace43dd3",
+        "size_in_bytes": 12769
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/search.py",
+        "path_type": "hardlink",
+        "sha256": "7d6914415c7f826f1e6db14094282ab712974fdacd6a1a49f8123fff71cd6698",
+        "sha256_in_prefix": "7d6914415c7f826f1e6db14094282ab712974fdacd6a1a49f8123fff71cd6698",
+        "size_in_bytes": 5626
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/show.py",
+        "path_type": "hardlink",
+        "sha256": "d180610a06b73c077cd6f4f797b5167e592d4a9079f9a62a41c2710553dacd53",
+        "sha256_in_prefix": "d180610a06b73c077cd6f4f797b5167e592d4a9079f9a62a41c2710553dacd53",
+        "size_in_bytes": 7857
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/uninstall.py",
+        "path_type": "hardlink",
+        "sha256": "ee9391ede9caefa8229b2c506f3c5c1b53acc8b5cbdc3bd7f77f7198cf05bed8",
+        "sha256_in_prefix": "ee9391ede9caefa8229b2c506f3c5c1b53acc8b5cbdc3bd7f77f7198cf05bed8",
+        "size_in_bytes": 3892
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/commands/wheel.py",
+        "path_type": "hardlink",
+        "sha256": "789461affaa834dc5602491d24236240cec25dde04d7f632421b2a26704f1868",
+        "sha256_in_prefix": "789461affaa834dc5602491d24236240cec25dde04d7f632421b2a26704f1868",
+        "size_in_bytes": 6414
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/configuration.py",
+        "path_type": "hardlink",
+        "sha256": "f8a3a893a8e1de11735cc3d014f275fc416306902c81ef914ab790b8b1cb9b3a",
+        "sha256_in_prefix": "f8a3a893a8e1de11735cc3d014f275fc416306902c81ef914ab790b8b1cb9b3a",
+        "size_in_bytes": 14005
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "1eaea4b7a8170608cd8ade614d358b03378234e2a807e374a46612a9e86b962f",
+        "sha256_in_prefix": "1eaea4b7a8170608cd8ade614d358b03378234e2a807e374a46612a9e86b962f",
+        "size_in_bytes": 858
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "af8847cffa61ecd0d335516f7a6ee26f3045d6ed52ac86e41056965dc3c7d3f8",
+        "sha256_in_prefix": "af8847cffa61ecd0d335516f7a6ee26f3045d6ed52ac86e41056965dc3c7d3f8",
+        "size_in_bytes": 744
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/__pycache__/base.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aecc43459aa91a43a25fedac684d243628ba0efc644a9e349fc538ce3b9062cf",
+        "sha256_in_prefix": "aecc43459aa91a43a25fedac684d243628ba0efc644a9e349fc538ce3b9062cf",
+        "size_in_bytes": 2483
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/__pycache__/installed.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6ed9f27bfcafece3e8c7e42ddb2b0fc44a59d61131ff156a91feb7570e9239dc",
+        "sha256_in_prefix": "6ed9f27bfcafece3e8c7e42ddb2b0fc44a59d61131ff156a91feb7570e9239dc",
+        "size_in_bytes": 1429
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/__pycache__/sdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4f42f4a4469fee1260558c7535cbd1ecb9ceba2e049664c4ed90e867dff96828",
+        "sha256_in_prefix": "4f42f4a4469fee1260558c7535cbd1ecb9ceba2e049664c4ed90e867dff96828",
+        "size_in_bytes": 5376
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/__pycache__/wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d0032d090bab53a26f735e606dd710d7a82c9deb669f6d8bed69b135ff431474",
+        "sha256_in_prefix": "d0032d090bab53a26f735e606dd710d7a82c9deb669f6d8bed69b135ff431474",
+        "size_in_bytes": 1824
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/base.py",
+        "path_type": "hardlink",
+        "sha256": "41e07daaf2970c88cb74f0431397cc8297c6a8c302afe828be7ba84271ae885f",
+        "sha256_in_prefix": "41e07daaf2970c88cb74f0431397cc8297c6a8c302afe828be7ba84271ae885f",
+        "size_in_bytes": 1783
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/installed.py",
+        "path_type": "hardlink",
+        "sha256": "4229c715b58043ca04d296c3f0c1595a4c259df5354184dc700d6f9e1ae560e5",
+        "sha256_in_prefix": "4229c715b58043ca04d296c3f0c1595a4c259df5354184dc700d6f9e1ae560e5",
+        "size_in_bytes": 842
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/sdist.py",
+        "path_type": "hardlink",
+        "sha256": "3e570fe1aebe47a73df179ce33e6fa2e46f7aecbe1f621b8a24f2c85a6a7af3b",
+        "sha256_in_prefix": "3e570fe1aebe47a73df179ce33e6fa2e46f7aecbe1f621b8a24f2c85a6a7af3b",
+        "size_in_bytes": 6751
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/distributions/wheel.py",
+        "path_type": "hardlink",
+        "sha256": "4c70587e7bfb555b7c99884c614b47d774b513b143c2d0f20df994725f1a8b41",
+        "sha256_in_prefix": "4c70587e7bfb555b7c99884c614b47d774b513b143c2d0f20df994725f1a8b41",
+        "size_in_bytes": 1317
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/exceptions.py",
+        "path_type": "hardlink",
+        "sha256": "dbf6f221222fde44a723ff53f84b1fc6bb742e74d181c507cb1bb4b70b078d06",
+        "sha256_in_prefix": "dbf6f221222fde44a723ff53f84b1fc6bb742e74d181c507cb1bb4b70b078d06",
+        "size_in_bytes": 26481
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/index/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "be9b7e25e4d979f87c6be142db665e0525c555bb817174868882e141925a3694",
+        "sha256_in_prefix": "be9b7e25e4d979f87c6be142db665e0525c555bb817174868882e141925a3694",
+        "size_in_bytes": 30
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/index/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "319a57d42f989918245aef2b8ece98620921a15e45c97c6ab2f32eef6d894693",
+        "sha256_in_prefix": "319a57d42f989918245aef2b8ece98620921a15e45c97c6ab2f32eef6d894693",
+        "size_in_bytes": 175
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/index/__pycache__/collector.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1edf12d7bf7894413f641f7c3d6d9c0f62abe6f1aa2977de8b08e8fe98f2a712",
+        "sha256_in_prefix": "1edf12d7bf7894413f641f7c3d6d9c0f62abe6f1aa2977de8b08e8fe98f2a712",
+        "size_in_bytes": 15039
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/index/__pycache__/package_finder.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "edcbef64f1ae985cbdad04f3abf4760eb4d7f371bbd2fe41e7b9476c9309d51b",
+        "sha256_in_prefix": "edcbef64f1ae985cbdad04f3abf4760eb4d7f371bbd2fe41e7b9476c9309d51b",
+        "size_in_bytes": 29496
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/index/__pycache__/sources.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b82bc49f814228f3d3dc74e53b26d9766600289b748019f9ca9e7d1bec60a77a",
+        "sha256_in_prefix": "b82bc49f814228f3d3dc74e53b26d9766600289b748019f9ca9e7d1bec60a77a",
+        "size_in_bytes": 8912
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/index/collector.py",
+        "path_type": "hardlink",
+        "sha256": "45d3ced092c0966c8158f0166073f24681a3cf718d01e4e78023646c67b2fe61",
+        "sha256_in_prefix": "45d3ced092c0966c8158f0166073f24681a3cf718d01e4e78023646c67b2fe61",
+        "size_in_bytes": 16265
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/index/package_finder.py",
+        "path_type": "hardlink",
+        "sha256": "9891c0963947787b9c972bb1b63bc164ee83b68bca8ec66317fb4287fc2ec791",
+        "sha256_in_prefix": "9891c0963947787b9c972bb1b63bc164ee83b68bca8ec66317fb4287fc2ec791",
+        "size_in_bytes": 38076
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/index/sources.py",
+        "path_type": "hardlink",
+        "sha256": "94f04b2b95e2cbc43a210322a36e9697ba1c7d938a9201a494804dc94276ddf2",
+        "sha256_in_prefix": "94f04b2b95e2cbc43a210322a36e9697ba1c7d938a9201a494804dc94276ddf2",
+        "size_in_bytes": 8632
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/locations/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "51a031799fdff77172a2eb857f8a7b497605fb85acb57b84bdddcb6e63c2027a",
+        "sha256_in_prefix": "51a031799fdff77172a2eb857f8a7b497605fb85acb57b84bdddcb6e63c2027a",
+        "size_in_bytes": 14925
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/locations/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2a2947098aa586dd73b03cf358eb80ef02e695282ad574e9ef34386f8f8cd13d",
+        "sha256_in_prefix": "2a2947098aa586dd73b03cf358eb80ef02e695282ad574e9ef34386f8f8cd13d",
+        "size_in_bytes": 10856
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/locations/__pycache__/_distutils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8c44f5e7b186ba2711caa468fcbd5bb3175650b6cd25eefa5661e70ebc42a2f6",
+        "sha256_in_prefix": "8c44f5e7b186ba2711caa468fcbd5bb3175650b6cd25eefa5661e70ebc42a2f6",
+        "size_in_bytes": 4508
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/locations/__pycache__/_sysconfig.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "223a89574543d27d1e817efe60118e87aff9e3d54d849f65bdf3b0451ee738f7",
+        "sha256_in_prefix": "223a89574543d27d1e817efe60118e87aff9e3d54d849f65bdf3b0451ee738f7",
+        "size_in_bytes": 5962
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/locations/__pycache__/base.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "385ba5a889fba133c0b21547a5e7ebea0480deea27fa0121ba08e4e9a7ddfec0",
+        "sha256_in_prefix": "385ba5a889fba133c0b21547a5e7ebea0480deea27fa0121ba08e4e9a7ddfec0",
+        "size_in_bytes": 2352
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/locations/_distutils.py",
+        "path_type": "hardlink",
+        "sha256": "c7a9f254b8fb5f5d58e2484875ffa6165c4c97615669db5512079bf2ea5cfd62",
+        "sha256_in_prefix": "c7a9f254b8fb5f5d58e2484875ffa6165c4c97615669db5512079bf2ea5cfd62",
+        "size_in_bytes": 6013
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/locations/_sysconfig.py",
+        "path_type": "hardlink",
+        "sha256": "206cddb3ad2ab059de468802fa8781698edb121de53edfefe3b90c2428505ec5",
+        "sha256_in_prefix": "206cddb3ad2ab059de468802fa8781698edb121de53edfefe3b90c2428505ec5",
+        "size_in_bytes": 7724
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/locations/base.py",
+        "path_type": "hardlink",
+        "sha256": "45088f8b5778155336071934e1d4215d9d8faa47a58c42f67d967d498a8843bf",
+        "sha256_in_prefix": "45088f8b5778155336071934e1d4215d9d8faa47a58c42f67d967d498a8843bf",
+        "size_in_bytes": 2556
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/main.py",
+        "path_type": "hardlink",
+        "sha256": "afe52751ef072e8e57149cfc8a74dc38e4e2bbfb313618076fa57094652594e2",
+        "sha256_in_prefix": "afe52751ef072e8e57149cfc8a74dc38e4e2bbfb313618076fa57094652594e2",
+        "size_in_bytes": 340
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "094f232b54d9b28ee338b76bd2c5fdc438eb72ce62cbc77b2112be86f6883b96",
+        "sha256_in_prefix": "094f232b54d9b28ee338b76bd2c5fdc438eb72ce62cbc77b2112be86f6883b96",
+        "size_in_bytes": 4337
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "57e4e0cee6a5da39067dd5ffd13668b49c05cce71d5b00d2a1f06278ef8d020d",
+        "sha256_in_prefix": "57e4e0cee6a5da39067dd5ffd13668b49c05cce71d5b00d2a1f06278ef8d020d",
+        "size_in_bytes": 4773
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/__pycache__/_json.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "81491ca3a88a7e2b8bc197be57f1b59b3a3eb9ddde4541e0fea3403e731fad81",
+        "sha256_in_prefix": "81491ca3a88a7e2b8bc197be57f1b59b3a3eb9ddde4541e0fea3403e731fad81",
+        "size_in_bytes": 2198
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/__pycache__/base.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cf1fb22a78e09aae3d1edd396ab2c86e53fc0292b62a0b3c72efba57f2d55c31",
+        "sha256_in_prefix": "cf1fb22a78e09aae3d1edd396ab2c86e53fc0292b62a0b3c72efba57f2d55c31",
+        "size_in_bytes": 27165
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/__pycache__/pkg_resources.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "37856a99ebb173815f59306e2776f14f0ddb42b7df20872a23d0b614417f9f72",
+        "sha256_in_prefix": "37856a99ebb173815f59306e2776f14f0ddb42b7df20872a23d0b614417f9f72",
+        "size_in_bytes": 10979
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/_json.py",
+        "path_type": "hardlink",
+        "sha256": "7b3ac861acc708834cd90524d5e03dc0400c8f769e19678356019a9605332a97",
+        "sha256_in_prefix": "7b3ac861acc708834cd90524d5e03dc0400c8f769e19678356019a9605332a97",
+        "size_in_bytes": 2707
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/base.py",
+        "path_type": "hardlink",
+        "sha256": "7edd0ae57360238113a999d1bf6f82b6f81888c38c01e18c033c53f9fe952c90",
+        "sha256_in_prefix": "7edd0ae57360238113a999d1bf6f82b6f81888c38c01e18c033c53f9fe952c90",
+        "size_in_bytes": 25298
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/importlib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "8d4522768c671dc7c84c71da0161b51b68b97dd058925bffb89723a36c7b5581",
+        "sha256_in_prefix": "8d4522768c671dc7c84c71da0161b51b68b97dd058925bffb89723a36c7b5581",
+        "size_in_bytes": 135
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/importlib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f1997377bd876a419c5adef6c7c0f15123027018ba137d8a7036cd741e062437",
+        "sha256_in_prefix": "f1997377bd876a419c5adef6c7c0f15123027018ba137d8a7036cd741e062437",
+        "size_in_bytes": 296
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/importlib/__pycache__/_compat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6688c7bee9153ac3d7f40b0d282305c85c490d10cb5dce19e54c09ad6c52c3e8",
+        "sha256_in_prefix": "6688c7bee9153ac3d7f40b0d282305c85c490d10cb5dce19e54c09ad6c52c3e8",
+        "size_in_bytes": 3453
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/importlib/__pycache__/_dists.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7f93d172b160935412091ce8c0194e163b93cd3e47849f3d493fa4cc764d8600",
+        "sha256_in_prefix": "7f93d172b160935412091ce8c0194e163b93cd3e47849f3d493fa4cc764d8600",
+        "size_in_bytes": 8746
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/importlib/__pycache__/_envs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "73c564e931f2ba828768287ae4e28486b0aa5f5b6b20804981dbd8e31201d5a1",
+        "sha256_in_prefix": "73c564e931f2ba828768287ae4e28486b0aa5f5b6b20804981dbd8e31201d5a1",
+        "size_in_bytes": 7592
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/importlib/_compat.py",
+        "path_type": "hardlink",
+        "sha256": "73a6aff2c3fc0418c066e152268c358967f28145cd337c514c29f99eac3a07d3",
+        "sha256_in_prefix": "73a6aff2c3fc0418c066e152268c358967f28145cd337c514c29f99eac3a07d3",
+        "size_in_bytes": 2796
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/importlib/_dists.py",
+        "path_type": "hardlink",
+        "sha256": "a0060277e67263e6998035e8d3aaa4f8139deaf5f283be60e3b59a2e502a747d",
+        "sha256_in_prefix": "a0060277e67263e6998035e8d3aaa4f8139deaf5f283be60e3b59a2e502a747d",
+        "size_in_bytes": 8260
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/importlib/_envs.py",
+        "path_type": "hardlink",
+        "sha256": "51407df345d2ac35ab329435fc6e398b4afc1ea960fed83720f43ade612a6cd7",
+        "sha256_in_prefix": "51407df345d2ac35ab329435fc6e398b4afc1ea960fed83720f43ade612a6cd7",
+        "size_in_bytes": 7431
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/metadata/pkg_resources.py",
+        "path_type": "hardlink",
+        "sha256": "534ec44c020d4867924417d6506f77138b5965b696fdfecf1b312a64dd21ba57",
+        "sha256_in_prefix": "534ec44c020d4867924417d6506f77138b5965b696fdfecf1b312a64dd21ba57",
+        "size_in_bytes": 10542
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "dc31d477fab1a4fa337f3a2ea2a6bd83db6cd42cebe6a6877c5c5b9f1ae27a93",
+        "sha256_in_prefix": "dc31d477fab1a4fa337f3a2ea2a6bd83db6cd42cebe6a6877c5c5b9f1ae27a93",
+        "size_in_bytes": 63
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "07125a3f4f7f31b0909941901fe49123bb48c7c9018f6983981b1e4e86d1d8d6",
+        "sha256_in_prefix": "07125a3f4f7f31b0909941901fe49123bb48c7c9018f6983981b1e4e86d1d8d6",
+        "size_in_bytes": 209
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/candidate.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1304f2457ab17477e1bf74ff436b442619b33791384ecf8de2ab0f1714bd00da",
+        "sha256_in_prefix": "1304f2457ab17477e1bf74ff436b442619b33791384ecf8de2ab0f1714bd00da",
+        "size_in_bytes": 1197
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/direct_url.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c3e3a932aaaf1380e4d5fb4c9992acf4f46362f6fdc908cad5ce2dcfd6cd76c6",
+        "sha256_in_prefix": "c3e3a932aaaf1380e4d5fb4c9992acf4f46362f6fdc908cad5ce2dcfd6cd76c6",
+        "size_in_bytes": 7315
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/format_control.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4d43fe9050c1586e9648f9bc58fd1269ebdde85936381f6b9b70d0b7837026be",
+        "sha256_in_prefix": "4d43fe9050c1586e9648f9bc58fd1269ebdde85936381f6b9b70d0b7837026be",
+        "size_in_bytes": 2657
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/index.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c65a06b41c12ebf3184c7095237b21c94f2f52448af062f60153fa9cab891717",
+        "sha256_in_prefix": "c65a06b41c12ebf3184c7095237b21c94f2f52448af062f60153fa9cab891717",
+        "size_in_bytes": 1179
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/installation_report.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a401f2e3d5616aaeaa26f0a71306cfd84a75496c00663a44d27864ab948a47ec",
+        "sha256_in_prefix": "a401f2e3d5616aaeaa26f0a71306cfd84a75496c00663a44d27864ab948a47ec",
+        "size_in_bytes": 1702
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/link.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e1db9c7b89e460d6fe74eb8c52f503bd205b14c234826dd43ed0471918d024e2",
+        "sha256_in_prefix": "e1db9c7b89e460d6fe74eb8c52f503bd205b14c234826dd43ed0471918d024e2",
+        "size_in_bytes": 18663
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/scheme.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "20a89285864c90edd9057adba443a5d0b272f388f9853b3b79c838f05b4996bb",
+        "sha256_in_prefix": "20a89285864c90edd9057adba443a5d0b272f388f9853b3b79c838f05b4996bb",
+        "size_in_bytes": 878
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/search_scope.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c29c2126f6c52f41668096112d2e93918a0b0f50eea9ed1117dcd1034c2512fa",
+        "sha256_in_prefix": "c29c2126f6c52f41668096112d2e93918a0b0f50eea9ed1117dcd1034c2512fa",
+        "size_in_bytes": 3421
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/selection_prefs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "75e954d12b694b2baa10fda6c9150f3c500cb7b86a805cd6c9f3837f976b5048",
+        "sha256_in_prefix": "75e954d12b694b2baa10fda6c9150f3c500cb7b86a805cd6c9f3837f976b5048",
+        "size_in_bytes": 1611
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/target_python.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fb16df64ae06c66a18bc8e5a27d567c1170d410b8661fb48af33d04da49adb1d",
+        "sha256_in_prefix": "fb16df64ae06c66a18bc8e5a27d567c1170d410b8661fb48af33d04da49adb1d",
+        "size_in_bytes": 3723
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/__pycache__/wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1ef92660bea7793f8461724b7f7673e2be228c42ab1dbdd7028c56fad62befc8",
+        "sha256_in_prefix": "1ef92660bea7793f8461724b7f7673e2be228c42ab1dbdd7028c56fad62befc8",
+        "size_in_bytes": 5018
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/candidate.py",
+        "path_type": "hardlink",
+        "sha256": "cf380546ec3f9163e32a91b0ecb0b4654303d8243611b7ab50862cf22ce37420",
+        "sha256_in_prefix": "cf380546ec3f9163e32a91b0ecb0b4654303d8243611b7ab50862cf22ce37420",
+        "size_in_bytes": 753
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/direct_url.py",
+        "path_type": "hardlink",
+        "sha256": "b81b58d871dddd33bd70a4095a1d1386f139151afe3164580a1454e081bd1d91",
+        "sha256_in_prefix": "b81b58d871dddd33bd70a4095a1d1386f139151afe3164580a1454e081bd1d91",
+        "size_in_bytes": 6578
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/format_control.py",
+        "path_type": "hardlink",
+        "sha256": "c2db10a922bd1da522371404b81f82eb67958a6c3a1b8fd5405c55f7efca0c11",
+        "sha256_in_prefix": "c2db10a922bd1da522371404b81f82eb67958a6c3a1b8fd5405c55f7efca0c11",
+        "size_in_bytes": 2486
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/index.py",
+        "path_type": "hardlink",
+        "sha256": "b589cbf28c468b8692356babd261bc0c03fbac2eb2ba16bf33024ef31c3472b2",
+        "sha256_in_prefix": "b589cbf28c468b8692356babd261bc0c03fbac2eb2ba16bf33024ef31c3472b2",
+        "size_in_bytes": 1030
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/installation_report.py",
+        "path_type": "hardlink",
+        "sha256": "cd1559a1acfedafb2b7b38ff1f784b3a131908af5ced36f35a00be8ce6a50f4d",
+        "sha256_in_prefix": "cd1559a1acfedafb2b7b38ff1f784b3a131908af5ced36f35a00be8ce6a50f4d",
+        "size_in_bytes": 2818
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/link.py",
+        "path_type": "hardlink",
+        "sha256": "190f21abbc7e14314fbf6e4d6e7daf78833e32506b1990c62ddeda65e1785eb8",
+        "sha256_in_prefix": "190f21abbc7e14314fbf6e4d6e7daf78833e32506b1990c62ddeda65e1785eb8",
+        "size_in_bytes": 21448
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/scheme.py",
+        "path_type": "hardlink",
+        "sha256": "3da9261c93377bc38e592645b5fcf5033edfd6678e3499e41ae431165b77c011",
+        "sha256_in_prefix": "3da9261c93377bc38e592645b5fcf5033edfd6678e3499e41ae431165b77c011",
+        "size_in_bytes": 575
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/search_scope.py",
+        "path_type": "hardlink",
+        "sha256": "ebb3449ec618f38efce12f8c33b7a442ea3d2972c7fbb333167b578daa6f028d",
+        "sha256_in_prefix": "ebb3449ec618f38efce12f8c33b7a442ea3d2972c7fbb333167b578daa6f028d",
+        "size_in_bytes": 4531
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/selection_prefs.py",
+        "path_type": "hardlink",
+        "sha256": "a9a15f0ecddc8aaa173e0eb1c78e4dd633cba9c70b270e0dd2ce0fd0fc874d0f",
+        "sha256_in_prefix": "a9a15f0ecddc8aaa173e0eb1c78e4dd633cba9c70b270e0dd2ce0fd0fc874d0f",
+        "size_in_bytes": 2015
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/target_python.py",
+        "path_type": "hardlink",
+        "sha256": "d97687dab679645f8ae707096c4306125ed2aab4d3a030cd92bb50daffefffe4",
+        "sha256_in_prefix": "d97687dab679645f8ae707096c4306125ed2aab4d3a030cd92bb50daffefffe4",
+        "size_in_bytes": 4271
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/models/wheel.py",
+        "path_type": "hardlink",
+        "sha256": "1bb74d0ffb3879b3e410bed1275a8263442151458820ae809e35a04404c5e67a",
+        "sha256_in_prefix": "1bb74d0ffb3879b3e410bed1275a8263442151458820ae809e35a04404c5e67a",
+        "size_in_bytes": 4539
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "8dfe93b799d5ffbce401106b2a88c85c8b607a3be87a054954a51b8406b92287",
+        "sha256_in_prefix": "8dfe93b799d5ffbce401106b2a88c85c8b607a3be87a054954a51b8406b92287",
+        "size_in_bytes": 50
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6377cd3eab3b39914e830b4b38edc4c4e1c79c5f5f139effe72e941fa2bec2ad",
+        "sha256_in_prefix": "6377cd3eab3b39914e830b4b38edc4c4e1c79c5f5f139effe72e941fa2bec2ad",
+        "size_in_bytes": 197
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/__pycache__/auth.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7acf21cc6976abf9c4e3a4ec336b995a70b8a7ffc9cfdb747d2937774bb7db83",
+        "sha256_in_prefix": "7acf21cc6976abf9c4e3a4ec336b995a70b8a7ffc9cfdb747d2937774bb7db83",
+        "size_in_bytes": 14405
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/__pycache__/cache.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "efb9c9827f350cd5f20e78fbcbdc0ff7fa1e74a38e79ab8a96b4f88e1f4a4205",
+        "sha256_in_prefix": "efb9c9827f350cd5f20e78fbcbdc0ff7fa1e74a38e79ab8a96b4f88e1f4a4205",
+        "size_in_bytes": 4729
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/__pycache__/download.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "28b6cc303b530e9b6744ab3e320fd44e4fe7b29bd65e388e9710e8ac667a3a0e",
+        "sha256_in_prefix": "28b6cc303b530e9b6744ab3e320fd44e4fe7b29bd65e388e9710e8ac667a3a0e",
+        "size_in_bytes": 5454
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/__pycache__/lazy_wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eeb0e5a6d327bd2ca8815f8c00e7329700fdf06a2d46c8200a3487ae237ef4bc",
+        "sha256_in_prefix": "eeb0e5a6d327bd2ca8815f8c00e7329700fdf06a2d46c8200a3487ae237ef4bc",
+        "size_in_bytes": 8342
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/__pycache__/session.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3ddf46d3f4813cb2be396b9619bb50e5e0d5deed8cb40a4968e58e4bcd4b1619",
+        "sha256_in_prefix": "3ddf46d3f4813cb2be396b9619bb50e5e0d5deed8cb40a4968e58e4bcd4b1619",
+        "size_in_bytes": 12546
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/__pycache__/utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c093b82a6203b8d2028b0f3e9075a8dd6f73087cea6c48cb99badcb41c62f648",
+        "sha256_in_prefix": "c093b82a6203b8d2028b0f3e9075a8dd6f73087cea6c48cb99badcb41c62f648",
+        "size_in_bytes": 1385
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/__pycache__/xmlrpc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "19c765db4ff7e7b6af907dc0ae9587fb279b62cd4102edce0b28c5469d9f307e",
+        "sha256_in_prefix": "19c765db4ff7e7b6af907dc0ae9587fb279b62cd4102edce0b28c5469d9f307e",
+        "size_in_bytes": 2039
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/auth.py",
+        "path_type": "hardlink",
+        "sha256": "0f88004a352baa80c5952b7a810efaeca0008efe8f532254d29b839615cd5511",
+        "sha256_in_prefix": "0f88004a352baa80c5952b7a810efaeca0008efe8f532254d29b839615cd5511",
+        "size_in_bytes": 20809
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/cache.py",
+        "path_type": "hardlink",
+        "sha256": "d3218c03711eb79f710522ed6cf01e9ef239ddd976f6850e7aa67673440bd92b",
+        "sha256_in_prefix": "d3218c03711eb79f710522ed6cf01e9ef239ddd976f6850e7aa67673440bd92b",
+        "size_in_bytes": 4614
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/download.py",
+        "path_type": "hardlink",
+        "sha256": "14b38fdbd74f6040818808bb7848ef01b364cb368a36a6f28ce4f69bc1cf5bc5",
+        "sha256_in_prefix": "14b38fdbd74f6040818808bb7848ef01b364cb368a36a6f28ce4f69bc1cf5bc5",
+        "size_in_bytes": 6048
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/lazy_wheel.py",
+        "path_type": "hardlink",
+        "sha256": "3c176832835040803ce058609dedfc8d6179d96e31fcab6c1e3c60bf876444a0",
+        "sha256_in_prefix": "3c176832835040803ce058609dedfc8d6179d96e31fcab6c1e3c60bf876444a0",
+        "size_in_bytes": 7622
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/session.py",
+        "path_type": "hardlink",
+        "sha256": "9ac3387acd7a2e698d118364ad8ca0f1f4dcee00076ca165b5ac1f28fdbb2ce2",
+        "sha256_in_prefix": "9ac3387acd7a2e698d118364ad8ca0f1f4dcee00076ca165b5ac1f28fdbb2ce2",
+        "size_in_bytes": 18771
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/utils.py",
+        "path_type": "hardlink",
+        "sha256": "2276b17a5f8dc41bb83d05a48f212b7677dec2c1427201e987b773475f856e86",
+        "sha256_in_prefix": "2276b17a5f8dc41bb83d05a48f212b7677dec2c1427201e987b773475f856e86",
+        "size_in_bytes": 4088
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/network/xmlrpc.py",
+        "path_type": "hardlink",
+        "sha256": "b00c7339a709f8dd4d5c63ef6a9f630b7cee6164a79efdc65ed811dbe13600f0",
+        "sha256_in_prefix": "b00c7339a709f8dd4d5c63ef6a9f630b7cee6164a79efdc65ed811dbe13600f0",
+        "size_in_bytes": 1838
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8ecae9bd5a5a17b9c6262fdc2fda82cbd0a3d70298b3161c57392ae14e3e4ce4",
+        "sha256_in_prefix": "8ecae9bd5a5a17b9c6262fdc2fda82cbd0a3d70298b3161c57392ae14e3e4ce4",
+        "size_in_bytes": 145
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/__pycache__/check.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9aa555a23f17ae6308c23f6e2d3f87af8f532421ebbc0e2e5592679f0616182c",
+        "sha256_in_prefix": "9aa555a23f17ae6308c23f6e2d3f87af8f532421ebbc0e2e5592679f0616182c",
+        "size_in_bytes": 4738
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/__pycache__/freeze.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "01546f1705e13ed9c644bbdc919aaa3e6433c425b93c793700c9a4fbfc6e28cf",
+        "sha256_in_prefix": "01546f1705e13ed9c644bbdc919aaa3e6433c425b93c793700c9a4fbfc6e28cf",
+        "size_in_bytes": 6249
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/__pycache__/prepare.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "204532bed9930ed5bffc2a852cc376b39868887e121f2bf9783fa78655029308",
+        "sha256_in_prefix": "204532bed9930ed5bffc2a852cc376b39868887e121f2bf9783fa78655029308",
+        "size_in_bytes": 15565
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5ffa030456c024c659d96cf6c908919fc52d9a569008eeec2d4ca2ffd890eaa8",
+        "sha256_in_prefix": "5ffa030456c024c659d96cf6c908919fc52d9a569008eeec2d4ca2ffd890eaa8",
+        "size_in_bytes": 151
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/__pycache__/build_tracker.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4700c0c4e36ecfca39b2b1a5f7beb661e6770f132608fe28bbdb5b5c201b2354",
+        "sha256_in_prefix": "4700c0c4e36ecfca39b2b1a5f7beb661e6770f132608fe28bbdb5b5c201b2354",
+        "size_in_bytes": 4869
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/__pycache__/metadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a83ee868d4b9bf20ae42008722b72d2407f885542817c55f349ac0f29e1f5e50",
+        "sha256_in_prefix": "a83ee868d4b9bf20ae42008722b72d2407f885542817c55f349ac0f29e1f5e50",
+        "size_in_bytes": 1368
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/__pycache__/metadata_editable.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "db124710d950a50ffe77ff5110af744dfa8403e1894ffb144b8e8969414af7ec",
+        "sha256_in_prefix": "db124710d950a50ffe77ff5110af744dfa8403e1894ffb144b8e8969414af7ec",
+        "size_in_bytes": 1416
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "131e053bf6b3b24783cdb37bebd3fd215a1343d8a2f15503b849de458a3fe83d",
+        "sha256_in_prefix": "131e053bf6b3b24783cdb37bebd3fd215a1343d8a2f15503b849de458a3fe83d",
+        "size_in_bytes": 2262
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/__pycache__/wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7d619d093fa60941e780538231219aa7322cc90628c2b4d6ebd7df7783db1d75",
+        "sha256_in_prefix": "7d619d093fa60941e780538231219aa7322cc90628c2b4d6ebd7df7783db1d75",
+        "size_in_bytes": 1152
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/__pycache__/wheel_editable.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9202c26a9007e4081845cf2531c35fa0dbbcb7ee2c7f5787602891b3d8277541",
+        "sha256_in_prefix": "9202c26a9007e4081845cf2531c35fa0dbbcb7ee2c7f5787602891b3d8277541",
+        "size_in_bytes": 1368
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "60ecbe424525921b2fe7330f84e62c299e79cd1a30c9b2376eca5eab4b9300a0",
+        "sha256_in_prefix": "60ecbe424525921b2fe7330f84e62c299e79cd1a30c9b2376eca5eab4b9300a0",
+        "size_in_bytes": 2639
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/build_tracker.py",
+        "path_type": "hardlink",
+        "sha256": "f80456fd37231c2397ec3d8d50e1a7b41e0581ce9be1aa25b179002ba0562fbc",
+        "sha256_in_prefix": "f80456fd37231c2397ec3d8d50e1a7b41e0581ce9be1aa25b179002ba0562fbc",
+        "size_in_bytes": 4774
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/metadata.py",
+        "path_type": "hardlink",
+        "sha256": "f52d02503f14dd0a99797a7e672b7c1f1c14f74944e10ae760382ba990f30677",
+        "sha256_in_prefix": "f52d02503f14dd0a99797a7e672b7c1f1c14f74944e10ae760382ba990f30677",
+        "size_in_bytes": 1422
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/metadata_editable.py",
+        "path_type": "hardlink",
+        "sha256": "c6503070ff6affcfdf9afff7237f70f4467b49057d867259afd56e4ecab663af",
+        "sha256_in_prefix": "c6503070ff6affcfdf9afff7237f70f4467b49057d867259afd56e4ecab663af",
+        "size_in_bytes": 1510
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/metadata_legacy.py",
+        "path_type": "hardlink",
+        "sha256": "f22ea2d50657f66fe528f4ad105b0728cd0c4f86be083e34f093b0f7d75a2e6a",
+        "sha256_in_prefix": "f22ea2d50657f66fe528f4ad105b0728cd0c4f86be083e34f093b0f7d75a2e6a",
+        "size_in_bytes": 2190
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/wheel.py",
+        "path_type": "hardlink",
+        "sha256": "b13d761412c0c430bac32ac3a2b87c92f719d631b9a889c2456cf33fe5242624",
+        "sha256_in_prefix": "b13d761412c0c430bac32ac3a2b87c92f719d631b9a889c2456cf33fe5242624",
+        "size_in_bytes": 1075
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/wheel_editable.py",
+        "path_type": "hardlink",
+        "sha256": "c8eb681face9024a0a60452dafc161ceb62790d1d0690063590d8761a7b53108",
+        "sha256_in_prefix": "c8eb681face9024a0a60452dafc161ceb62790d1d0690063590d8761a7b53108",
+        "size_in_bytes": 1417
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/build/wheel_legacy.py",
+        "path_type": "hardlink",
+        "sha256": "2beea43619a3fb5c43178e67cb5ca178c7ab174ba2e04a1008bcc4a0787afad7",
+        "sha256_in_prefix": "2beea43619a3fb5c43178e67cb5ca178c7ab174ba2e04a1008bcc4a0787afad7",
+        "size_in_bytes": 3045
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/check.py",
+        "path_type": "hardlink",
+        "sha256": "2f6e2f44bf1559bcb2c1da1e02133cf5609df332d39e321b50b94a7a552021e7",
+        "sha256_in_prefix": "2f6e2f44bf1559bcb2c1da1e02133cf5609df332d39e321b50b94a7a552021e7",
+        "size_in_bytes": 5912
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/freeze.py",
+        "path_type": "hardlink",
+        "sha256": "d7f33bf630102a70b15abf8a082987b955ce54519a5091e6a162df173821ecae",
+        "sha256_in_prefix": "d7f33bf630102a70b15abf8a082987b955ce54519a5091e6a162df173821ecae",
+        "size_in_bytes": 9843
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/install/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "997ee1c83d863413b69851a8903437d2bfc65efed8fcf2ddb71714bf5e387beb",
+        "sha256_in_prefix": "997ee1c83d863413b69851a8903437d2bfc65efed8fcf2ddb71714bf5e387beb",
+        "size_in_bytes": 51
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/install/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ad2e82939edac5159f59cc82c555718f8356550e2b7754bd2c52a13b791cb6e3",
+        "sha256_in_prefix": "ad2e82939edac5159f59cc82c555718f8356550e2b7754bd2c52a13b791cb6e3",
+        "size_in_bytes": 209
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/install/__pycache__/editable_legacy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "be185ef1708800d93cb69ff3db1d32d46e92f76f9c79dcc0d798ce58de0d2c51",
+        "sha256_in_prefix": "be185ef1708800d93cb69ff3db1d32d46e92f76f9c79dcc0d798ce58de0d2c51",
+        "size_in_bytes": 1376
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/install/__pycache__/wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "57ad13fb18d9541679ce6a0f0f86ca091ac0a2075a38e3ad4c67b9ac1ccc5d28",
+        "sha256_in_prefix": "57ad13fb18d9541679ce6a0f0f86ca091ac0a2075a38e3ad4c67b9ac1ccc5d28",
+        "size_in_bytes": 21296
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/install/editable_legacy.py",
+        "path_type": "hardlink",
+        "sha256": "3e812c3443c66c8676c90a613ec9984ca2ce08cb3882fe4e7027735b5db835c0",
+        "sha256_in_prefix": "3e812c3443c66c8676c90a613ec9984ca2ce08cb3882fe4e7027735b5db835c0",
+        "size_in_bytes": 1283
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/install/wheel.py",
+        "path_type": "hardlink",
+        "sha256": "5f9233f72520e4b94ae55350f60da291ce9d711bbc10f8bf4948b98ae103460a",
+        "sha256_in_prefix": "5f9233f72520e4b94ae55350f60da291ce9d711bbc10f8bf4948b98ae103460a",
+        "size_in_bytes": 27615
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/operations/prepare.py",
+        "path_type": "hardlink",
+        "sha256": "8e8589c0f92ea86b1c42054d2262caef57bd8516a9c0abd108cf07725cac9af5",
+        "sha256_in_prefix": "8e8589c0f92ea86b1c42054d2262caef57bd8516a9c0abd108cf07725cac9af5",
+        "size_in_bytes": 28118
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/pyproject.py",
+        "path_type": "hardlink",
+        "sha256": "18b27aad6452e7fda7a0a75a8e88682f20edcb9ed9ed05e17140188219939d67",
+        "sha256_in_prefix": "18b27aad6452e7fda7a0a75a8e88682f20edcb9ed9ed05e17140188219939d67",
+        "size_in_bytes": 7286
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "1f1045b59cbf05b09c94b82bdbac1a32da7361d3b94f7bf178fbe91805d2b79b",
+        "sha256_in_prefix": "1f1045b59cbf05b09c94b82bdbac1a32da7361d3b94f7bf178fbe91805d2b79b",
+        "size_in_bytes": 2653
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4d858992a8beb33d062ed16829749de4cf332b76c805388768f8529f65a0009c",
+        "sha256_in_prefix": "4d858992a8beb33d062ed16829749de4cf332b76c805388768f8529f65a0009c",
+        "size_in_bytes": 2237
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/__pycache__/constructors.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "333cd4fffb95674e8602dc0b3b796f953f631f1b2b233f22e850e513ff1c7030",
+        "sha256_in_prefix": "333cd4fffb95674e8602dc0b3b796f953f631f1b2b233f22e850e513ff1c7030",
+        "size_in_bytes": 13936
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/__pycache__/req_file.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c4eeb73d756060b507113e168d4d5d2c22fb95b6340c3d75ced32dd73f7be4d0",
+        "sha256_in_prefix": "c4eeb73d756060b507113e168d4d5d2c22fb95b6340c3d75ced32dd73f7be4d0",
+        "size_in_bytes": 15381
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/__pycache__/req_install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de5183a2127be16e26f15b2bd9406dfc3df58ec5b75fae4e290e482ace915c04",
+        "sha256_in_prefix": "de5183a2127be16e26f15b2bd9406dfc3df58ec5b75fae4e290e482ace915c04",
+        "size_in_bytes": 24732
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/__pycache__/req_set.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b74283c063810f2f84d6704c6c07ac12fbfa54ddffc0d4db0c584d35c035813d",
+        "sha256_in_prefix": "b74283c063810f2f84d6704c6c07ac12fbfa54ddffc0d4db0c584d35c035813d",
+        "size_in_bytes": 3893
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/__pycache__/req_uninstall.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eaed7e2190bbdb868454d8157083fb4a42299b585e71b035f3b6819ab5b3222e",
+        "sha256_in_prefix": "eaed7e2190bbdb868454d8157083fb4a42299b585e71b035f3b6819ab5b3222e",
+        "size_in_bytes": 18585
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/constructors.py",
+        "path_type": "hardlink",
+        "sha256": "bf5ab308dd66225770c7e9c2acf73c24ee25c649b716ff0ce515afb7c2c84a37",
+        "sha256_in_prefix": "bf5ab308dd66225770c7e9c2acf73c24ee25c649b716ff0ce515afb7c2c84a37",
+        "size_in_bytes": 18430
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/req_file.py",
+        "path_type": "hardlink",
+        "sha256": "7b2b3cd8c72068808e1a27365194478c3ef6d2988a24fc2679261d5e55b097ac",
+        "sha256_in_prefix": "7b2b3cd8c72068808e1a27365194478c3ef6d2988a24fc2679261d5e55b097ac",
+        "size_in_bytes": 20234
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/req_install.py",
+        "path_type": "hardlink",
+        "sha256": "04ca6dc47620dae1bf6feec714450b3dbde7bb0d053006ee79af334eadab13bc",
+        "sha256_in_prefix": "04ca6dc47620dae1bf6feec714450b3dbde7bb0d053006ee79af334eadab13bc",
+        "size_in_bytes": 35786
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/req_set.py",
+        "path_type": "hardlink",
+        "sha256": "8f77ac1b4b3a4b3a1545e5fdad69f8ae960db72113fdfc316f024f4629af471a",
+        "sha256_in_prefix": "8f77ac1b4b3a4b3a1545e5fdad69f8ae960db72113fdfc316f024f4629af471a",
+        "size_in_bytes": 2858
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/req/req_uninstall.py",
+        "path_type": "hardlink",
+        "sha256": "ab30c8c49a3e3844d6a866a2b3bb523020dc59b013600053f9389dde2b72174b",
+        "sha256_in_prefix": "ab30c8c49a3e3844d6a866a2b3bb523020dc59b013600053f9389dde2b72174b",
+        "size_in_bytes": 23853
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a8bb049df31fadb260d0f93afb5d928511d672cdfb2dff929ca1dba9094d0a14",
+        "sha256_in_prefix": "a8bb049df31fadb260d0f93afb5d928511d672cdfb2dff929ca1dba9094d0a14",
+        "size_in_bytes": 145
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/__pycache__/base.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7e34d42e2aa48d6fd3c32106d5db97757d320076b00bf5cefff095e587997069",
+        "sha256_in_prefix": "7e34d42e2aa48d6fd3c32106d5db97757d320076b00bf5cefff095e587997069",
+        "size_in_bytes": 1002
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/base.py",
+        "path_type": "hardlink",
+        "sha256": "aa59a1df6e520557ef1ba31ef6073936c879b1dc07070cc706ae9a117b4ab0b0",
+        "sha256_in_prefix": "aa59a1df6e520557ef1ba31ef6073936c879b1dc07070cc706ae9a117b4ab0b0",
+        "size_in_bytes": 583
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/legacy/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/legacy/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "01f0351a79c05fc8fe4b5ac90e1bc2c17e57145bc8d146a794843fdad667ffa1",
+        "sha256_in_prefix": "01f0351a79c05fc8fe4b5ac90e1bc2c17e57145bc8d146a794843fdad667ffa1",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6c88f174801be81ed659370930b79612ece4f23d4e1f4602dccc336ced9b3e52",
+        "sha256_in_prefix": "6c88f174801be81ed659370930b79612ece4f23d4e1f4602dccc336ced9b3e52",
+        "size_in_bytes": 14873
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/legacy/resolver.py",
+        "path_type": "hardlink",
+        "sha256": "dc766224145dd454cdea3429238a913bcf936cb61e21b5134ba3c5bd79d7b36c",
+        "sha256_in_prefix": "dc766224145dd454cdea3429238a913bcf936cb61e21b5134ba3c5bd79d7b36c",
+        "size_in_bytes": 24068
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f3a05bf7ea04c21be6a1c0ddc6731d1058e53db690e7c7f661b780aebf9fb3ca",
+        "sha256_in_prefix": "f3a05bf7ea04c21be6a1c0ddc6731d1058e53db690e7c7f661b780aebf9fb3ca",
+        "size_in_bytes": 156
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/base.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a417061490ea5b8bd2201d935c7e31414fd6180c21344e81e9a6df9e56151f29",
+        "sha256_in_prefix": "a417061490ea5b8bd2201d935c7e31414fd6180c21344e81e9a6df9e56151f29",
+        "size_in_bytes": 6219
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e5918039d064578630364f6351594685de57a4715e8500c9c90193ae3ee15a7f",
+        "sha256_in_prefix": "e5918039d064578630364f6351594685de57a4715e8500c9c90193ae3ee15a7f",
+        "size_in_bytes": 19598
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d7e2eb40b5d251096e8c28e048989d858fda325189a9d4619d96f290dbcb99fc",
+        "sha256_in_prefix": "d7e2eb40b5d251096e8c28e048989d858fda325189a9d4619d96f290dbcb99fc",
+        "size_in_bytes": 21531
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4ca521ca50e530ff74d742c57bc68bd80678d26ba3a14ba47d56c5c3f7aaed94",
+        "sha256_in_prefix": "4ca521ca50e530ff74d742c57bc68bd80678d26ba3a14ba47d56c5c3f7aaed94",
+        "size_in_bytes": 5144
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bc28fd61761bee8e0a38a492cb08dc07f489641db6263404716aeaec80b6071e",
+        "sha256_in_prefix": "bc28fd61761bee8e0a38a492cb08dc07f489641db6263404716aeaec80b6071e",
+        "size_in_bytes": 7891
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d360e00875c9492612e24450d7a8d940fe52cd99b2f1112542030b823d1692b2",
+        "sha256_in_prefix": "d360e00875c9492612e24450d7a8d940fe52cd99b2f1112542030b823d1692b2",
+        "size_in_bytes": 3809
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "83d4266b7c1dd9897cb59dad7d48a29640d7aaf827b1627f96b6e4f1af9ba060",
+        "sha256_in_prefix": "83d4266b7c1dd9897cb59dad7d48a29640d7aaf827b1627f96b6e4f1af9ba060",
+        "size_in_bytes": 10718
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7a23ba73bf0337f7968b73e5d46b5587bc4f186f2e8fbcc4acc8ef699ef30c2a",
+        "sha256_in_prefix": "7a23ba73bf0337f7968b73e5d46b5587bc4f186f2e8fbcc4acc8ef699ef30c2a",
+        "size_in_bytes": 8656
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/base.py",
+        "path_type": "hardlink",
+        "sha256": "0c27faebd16cab2418e6ea9779e3c31d06357b840efa9073587f0ed2cf7e2bde",
+        "sha256_in_prefix": "0c27faebd16cab2418e6ea9779e3c31d06357b840efa9073587f0ed2cf7e2bde",
+        "size_in_bytes": 5023
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/candidates.py",
+        "path_type": "hardlink",
+        "sha256": "e54675ba93679aab0ffa798465a0d8c5a0600a87a3c3f7b65951a6980bc1c577",
+        "sha256_in_prefix": "e54675ba93679aab0ffa798465a0d8c5a0600a87a3c3f7b65951a6980bc1c577",
+        "size_in_bytes": 20001
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/factory.py",
+        "path_type": "hardlink",
+        "sha256": "30938b499258f3fdbc3cf75cbada10ea08c9ff57810ede99d5e76d7d32724781",
+        "sha256_in_prefix": "30938b499258f3fdbc3cf75cbada10ea08c9ff57810ede99d5e76d7d32724781",
+        "size_in_bytes": 32659
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py",
+        "path_type": "hardlink",
+        "sha256": "f61ad3c90a85be5f48ed38e2efd1750311efdfd421d6b909ffb75e48748c7d07",
+        "sha256_in_prefix": "f61ad3c90a85be5f48ed38e2efd1750311efdfd421d6b909ffb75e48748c7d07",
+        "size_in_bytes": 6383
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/provider.py",
+        "path_type": "hardlink",
+        "sha256": "6dcb059d8be59ad07cd1cc15756d5f23082897c64daf57f5547c914e4cf8ed23",
+        "sha256_in_prefix": "6dcb059d8be59ad07cd1cc15756d5f23082897c64daf57f5547c914e4cf8ed23",
+        "size_in_bytes": 9935
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/reporter.py",
+        "path_type": "hardlink",
+        "sha256": "d3426da171244e5c34fab97fb25e7877bd5abf03ac247b7d1861dcae3e52cdad",
+        "sha256_in_prefix": "d3426da171244e5c34fab97fb25e7877bd5abf03ac247b7d1861dcae3e52cdad",
+        "size_in_bytes": 3168
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/requirements.py",
+        "path_type": "hardlink",
+        "sha256": "ec91b867bd9ee58938bd4d12e6e946bdba93cb814c406621639cd0857f734ed6",
+        "sha256_in_prefix": "ec91b867bd9ee58938bd4d12e6e946bdba93cb814c406621639cd0857f734ed6",
+        "size_in_bytes": 8065
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/resolution/resolvelib/resolver.py",
+        "path_type": "hardlink",
+        "sha256": "9cb24eb15304562da0414549a1414a31901ebb67fb19132318cbcd496cb3d017",
+        "sha256_in_prefix": "9cb24eb15304562da0414549a1414a31901ebb67fb19132318cbcd496cb3d017",
+        "size_in_bytes": 12592
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/self_outdated_check.py",
+        "path_type": "hardlink",
+        "sha256": "d4f16db6dbcb01ec82551ded3e806adac3a53c3d0827e292a94e9b7351d493d7",
+        "sha256_in_prefix": "d4f16db6dbcb01ec82551ded3e806adac3a53c3d0827e292a94e9b7351d493d7",
+        "size_in_bytes": 8318
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "215418664a8984788af10dd96aa2fd50d754dc044742ecf44152a05cc31924d3",
+        "sha256_in_prefix": "215418664a8984788af10dd96aa2fd50d754dc044742ecf44152a05cc31924d3",
+        "size_in_bytes": 140
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/_jaraco_text.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7aa62f39b9ef23d4be895da799befbc26c0b3d78ad3cd5e052db32af88058d1c",
+        "sha256_in_prefix": "7aa62f39b9ef23d4be895da799befbc26c0b3d78ad3cd5e052db32af88058d1c",
+        "size_in_bytes": 3777
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/_log.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1d22a3816588772b2933ae7e10672689148ce9360a475303006223174ed33db5",
+        "sha256_in_prefix": "1d22a3816588772b2933ae7e10672689148ce9360a475303006223174ed33db5",
+        "size_in_bytes": 1465
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/appdirs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9932c66f4e299f1b1b7793bcda8430cc255b8fc1c9d3066046fd25cf4406e40d",
+        "sha256_in_prefix": "9932c66f4e299f1b1b7793bcda8430cc255b8fc1c9d3066046fd25cf4406e40d",
+        "size_in_bytes": 1571
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/compat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "456354dd2da3de5f4a5ce5e319d28d8fb02664d12694cbdb0d0aa8b06780c2a5",
+        "sha256_in_prefix": "456354dd2da3de5f4a5ce5e319d28d8fb02664d12694cbdb0d0aa8b06780c2a5",
+        "size_in_bytes": 1897
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/compatibility_tags.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2157a8ebab2b8faff4c48cafda291fccf9ac456f028ca4650367748369e8a16e",
+        "sha256_in_prefix": "2157a8ebab2b8faff4c48cafda291fccf9ac456f028ca4650367748369e8a16e",
+        "size_in_bytes": 4520
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/datetime.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ae1c5c80d2c0ba790449c0ac8ebbf83963127b610525f1a0c97dd9ba98e211c1",
+        "sha256_in_prefix": "ae1c5c80d2c0ba790449c0ac8ebbf83963127b610525f1a0c97dd9ba98e211c1",
+        "size_in_bytes": 459
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/deprecation.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "401102a6307a4c1ddbd6b9be73b282fb6ce16bbf99bc3a6c5433cb92157303d6",
+        "sha256_in_prefix": "401102a6307a4c1ddbd6b9be73b282fb6ce16bbf99bc3a6c5433cb92157303d6",
+        "size_in_bytes": 3197
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/direct_url_helpers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "23eecc333f84d97b6c4258f7ef6210575f6a02d63253db56bcafdf0e9f21b756",
+        "sha256_in_prefix": "23eecc333f84d97b6c4258f7ef6210575f6a02d63253db56bcafdf0e9f21b756",
+        "size_in_bytes": 2024
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/egg_link.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a7ac3293a3525eb3f5bc644f54ae418be5f6d2b34e0008029be25c8857a6c4c0",
+        "sha256_in_prefix": "a7ac3293a3525eb3f5bc644f54ae418be5f6d2b34e0008029be25c8857a6c4c0",
+        "size_in_bytes": 2347
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/entrypoints.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "14084c7a66b4216f6e08c754b10f7731ff76b4ca5c0b516f4ee9823a94257805",
+        "sha256_in_prefix": "14084c7a66b4216f6e08c754b10f7731ff76b4ca5c0b516f4ee9823a94257805",
+        "size_in_bytes": 2647
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/filesystem.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c6d7e76652c0712460ccd40d359590b787787652f29051f525a3cc9b6ba3ac98",
+        "sha256_in_prefix": "c6d7e76652c0712460ccd40d359590b787787652f29051f525a3cc9b6ba3ac98",
+        "size_in_bytes": 4333
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/filetypes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e0b206f15510b9beabc4f0226939302c2b46b607fb6fc6a10926c53c3b9a1e89",
+        "sha256_in_prefix": "e0b206f15510b9beabc4f0226939302c2b46b607fb6fc6a10926c53c3b9a1e89",
+        "size_in_bytes": 890
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/glibc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "abea92196d962c33ee241f2c6bd59020c9dda8c09b313330766b50b3fcae5802",
+        "sha256_in_prefix": "abea92196d962c33ee241f2c6bd59020c9dda8c09b313330766b50b3fcae5802",
+        "size_in_bytes": 1700
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/hashes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bbf5f62b1ed0bee4c1ff7a1b22edcebc986bdf3722dcd42f7e1f69d53af18813",
+        "sha256_in_prefix": "bbf5f62b1ed0bee4c1ff7a1b22edcebc986bdf3722dcd42f7e1f69d53af18813",
+        "size_in_bytes": 5556
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/logging.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1aa3fb4f5b717b0c59f0bbbdf9f938cdc8d58d19dda04eb26952a3604a0213a3",
+        "sha256_in_prefix": "1aa3fb4f5b717b0c59f0bbbdf9f938cdc8d58d19dda04eb26952a3604a0213a3",
+        "size_in_bytes": 9875
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/misc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a49fc6920f3807f41da1f043ef9bf62629d76dbba09f6daf4a2ddfa6c170fa6d",
+        "sha256_in_prefix": "a49fc6920f3807f41da1f043ef9bf62629d76dbba09f6daf4a2ddfa6c170fa6d",
+        "size_in_bytes": 22952
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/packaging.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "14ad0cf5d81d5eb350cbdd6d52d9f59ef053f0ca2c9c03ac0e9b421faec5c28d",
+        "sha256_in_prefix": "14ad0cf5d81d5eb350cbdd6d52d9f59ef053f0ca2c9c03ac0e9b421faec5c28d",
+        "size_in_bytes": 2047
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/retry.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c04875f9915114cbeac976b75bd44cd10ad9b39a3f2e5476856a77d4af18f312",
+        "sha256_in_prefix": "c04875f9915114cbeac976b75bd44cd10ad9b39a3f2e5476856a77d4af18f312",
+        "size_in_bytes": 1552
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/setuptools_build.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d4a4e759feba9cace791a77e36643153a4abda136eeb6f4eae84a22d7c3e4f38",
+        "sha256_in_prefix": "d4a4e759feba9cace791a77e36643153a4abda136eeb6f4eae84a22d7c3e4f38",
+        "size_in_bytes": 3745
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/subprocess.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6949152941c86daaf150a57cacdda843dd40868bd3319c481f74bdcccaba519a",
+        "sha256_in_prefix": "6949152941c86daaf150a57cacdda843dd40868bd3319c481f74bdcccaba519a",
+        "size_in_bytes": 5610
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/temp_dir.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bd61b6d9ecbc930cedcde81e6f6c5f6681082a5d457de5d2e7bf55274f5228c0",
+        "sha256_in_prefix": "bd61b6d9ecbc930cedcde81e6f6c5f6681082a5d457de5d2e7bf55274f5228c0",
+        "size_in_bytes": 8207
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/unpacking.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "afb5fdb2042b361bb2f4c1e65fb5a2852aaacde73e985447eac1da18103c3bb1",
+        "sha256_in_prefix": "afb5fdb2042b361bb2f4c1e65fb5a2852aaacde73e985447eac1da18103c3bb1",
+        "size_in_bytes": 8063
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/urls.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7bf51b6654831a579f9e28798c7560dda20cbf8878f1379881e94f7072e8f1aa",
+        "sha256_in_prefix": "7bf51b6654831a579f9e28798c7560dda20cbf8878f1379881e94f7072e8f1aa",
+        "size_in_bytes": 1324
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/virtualenv.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2fc8cf04daae4749ab4fe8bacdf7cfd781daf7d25fca066167a5a4950349efaf",
+        "sha256_in_prefix": "2fc8cf04daae4749ab4fe8bacdf7cfd781daf7d25fca066167a5a4950349efaf",
+        "size_in_bytes": 3234
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/__pycache__/wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "074100f39c289fce664e0dd098c54af44fe380c1c100ab17bc5815e925bb19ba",
+        "sha256_in_prefix": "074100f39c289fce664e0dd098c54af44fe380c1c100ab17bc5815e925bb19ba",
+        "size_in_bytes": 4402
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/_jaraco_text.py",
+        "path_type": "hardlink",
+        "sha256": "335e6e50f221e4da4fd6d754181c516aeeaad59004b48f3e5f22c4113b1c15f1",
+        "sha256_in_prefix": "335e6e50f221e4da4fd6d754181c516aeeaad59004b48f3e5f22c4113b1c15f1",
+        "size_in_bytes": 3350
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/_log.py",
+        "path_type": "hardlink",
+        "sha256": "fa31cb384fd31da673e4115c0a7a122fd11802d2749d77a6e3db3da1fe23bcac",
+        "sha256_in_prefix": "fa31cb384fd31da673e4115c0a7a122fd11802d2749d77a6e3db3da1fe23bcac",
+        "size_in_bytes": 1015
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/appdirs.py",
+        "path_type": "hardlink",
+        "sha256": "b3081c4ca3a6ddd68b7974d6eafe41512d938b646f1271914181ffc835e4940a",
+        "sha256_in_prefix": "b3081c4ca3a6ddd68b7974d6eafe41512d938b646f1271914181ffc835e4940a",
+        "size_in_bytes": 1665
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/compat.py",
+        "path_type": "hardlink",
+        "sha256": "724905bde0626108d15a390db1a8edfe858f4b9eed26f13c5f1a02e0e2188026",
+        "sha256_in_prefix": "724905bde0626108d15a390db1a8edfe858f4b9eed26f13c5f1a02e0e2188026",
+        "size_in_bytes": 2399
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/compatibility_tags.py",
+        "path_type": "hardlink",
+        "sha256": "396ab96b11e95be30410fced19dbe0003ae024f01c57d6bcf11c66e19f1506cf",
+        "sha256_in_prefix": "396ab96b11e95be30410fced19dbe0003ae024f01c57d6bcf11c66e19f1506cf",
+        "size_in_bytes": 6272
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/datetime.py",
+        "path_type": "hardlink",
+        "sha256": "9b6d58df002d41cfa38ba55e6fa93f33983a034672148e1e81c853767c21fa94",
+        "sha256_in_prefix": "9b6d58df002d41cfa38ba55e6fa93f33983a034672148e1e81c853767c21fa94",
+        "size_in_bytes": 242
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/deprecation.py",
+        "path_type": "hardlink",
+        "sha256": "93b420fd404069a4ddcaaf3661501103a0fb4667064d71afedf9df7208a08f84",
+        "sha256_in_prefix": "93b420fd404069a4ddcaaf3661501103a0fb4667064d71afedf9df7208a08f84",
+        "size_in_bytes": 3707
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/direct_url_helpers.py",
+        "path_type": "hardlink",
+        "sha256": "af6311b64543002bfd006a983830540bd0a3c20b6c514d6cebc86681f08932d0",
+        "sha256_in_prefix": "af6311b64543002bfd006a983830540bd0a3c20b6c514d6cebc86681f08932d0",
+        "size_in_bytes": 3196
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/egg_link.py",
+        "path_type": "hardlink",
+        "sha256": "d0578f6685182afe11190dadeb1ef0e59e36ef06c0fd4a375999c092b82cbaaa",
+        "sha256_in_prefix": "d0578f6685182afe11190dadeb1ef0e59e36ef06c0fd4a375999c092b82cbaaa",
+        "size_in_bytes": 2463
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/entrypoints.py",
+        "path_type": "hardlink",
+        "sha256": "62584b4d1976a07040baa85cfb398bed4492ebb4cf5951c89a3780407ade6534",
+        "sha256_in_prefix": "62584b4d1976a07040baa85cfb398bed4492ebb4cf5951c89a3780407ade6534",
+        "size_in_bytes": 3064
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/filesystem.py",
+        "path_type": "hardlink",
+        "sha256": "6a3bc0faae28725896f643e9f18aae87ee2fb2c5dbbbe50a6e8e4557d5785fae",
+        "sha256_in_prefix": "6a3bc0faae28725896f643e9f18aae87ee2fb2c5dbbbe50a6e8e4557d5785fae",
+        "size_in_bytes": 4950
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/filetypes.py",
+        "path_type": "hardlink",
+        "sha256": "8bc5c04347850a8836e85c3dc95d186f5ca002a298075c3d0b3f67d1f8fc8195",
+        "sha256_in_prefix": "8bc5c04347850a8836e85c3dc95d186f5ca002a298075c3d0b3f67d1f8fc8195",
+        "size_in_bytes": 716
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/glibc.py",
+        "path_type": "hardlink",
+        "sha256": "bd4916abfd6926ecdc60d70628b9509800685228ac2bc9e8618d7273c5aae30e",
+        "sha256_in_prefix": "bd4916abfd6926ecdc60d70628b9509800685228ac2bc9e8618d7273c5aae30e",
+        "size_in_bytes": 3734
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/hashes.py",
+        "path_type": "hardlink",
+        "sha256": "5c618b2f4006f3e4615a7cb3f3bc45e8c159fbe04a69d1d4df90f8ede02908a2",
+        "sha256_in_prefix": "5c618b2f4006f3e4615a7cb3f3bc45e8c159fbe04a69d1d4df90f8ede02908a2",
+        "size_in_bytes": 4972
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/logging.py",
+        "path_type": "hardlink",
+        "sha256": "38d7dbae1683db8f1a924a2c2bbf627fdee7db4100071c233b1a79744e510916",
+        "sha256_in_prefix": "38d7dbae1683db8f1a924a2c2bbf627fdee7db4100071c233b1a79744e510916",
+        "size_in_bytes": 11845
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/misc.py",
+        "path_type": "hardlink",
+        "sha256": "0d69d8c41508b63469ee1871120e2287a3fa6292abca433ce9d6e2fc4714f124",
+        "sha256_in_prefix": "0d69d8c41508b63469ee1871120e2287a3fa6292abca433ce9d6e2fc4714f124",
+        "size_in_bytes": 23450
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/packaging.py",
+        "path_type": "hardlink",
+        "sha256": "726f97ff41d51d5fe3470515661e80b845aa4a2b737fc129689ed4bf6506bba0",
+        "sha256_in_prefix": "726f97ff41d51d5fe3470515661e80b845aa4a2b737fc129689ed4bf6506bba0",
+        "size_in_bytes": 2142
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/retry.py",
+        "path_type": "hardlink",
+        "sha256": "9a115bca45e38539d97e0cdebb2faf97d73c9c40a7627fc232dc0d257dad6334",
+        "sha256_in_prefix": "9a115bca45e38539d97e0cdebb2faf97d73c9c40a7627fc232dc0d257dad6334",
+        "size_in_bytes": 1392
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/setuptools_build.py",
+        "path_type": "hardlink",
+        "sha256": "a2e5e9b9dfa3792f313f24cfb1727e9b7e0d3ef2b9a2ce39a2d03375257f2091",
+        "sha256_in_prefix": "a2e5e9b9dfa3792f313f24cfb1727e9b7e0d3ef2b9a2ce39a2d03375257f2091",
+        "size_in_bytes": 4435
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/subprocess.py",
+        "path_type": "hardlink",
+        "sha256": "12cbea49189230717df13f13c66bba34b53753ef8ca534d08ed36028fd0ffbe3",
+        "sha256_in_prefix": "12cbea49189230717df13f13c66bba34b53753ef8ca534d08ed36028fd0ffbe3",
+        "size_in_bytes": 8988
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/temp_dir.py",
+        "path_type": "hardlink",
+        "sha256": "e6a3977bc33825e63abda15033cebb779ce4a756d2c0c67e293e63ca698fd198",
+        "sha256_in_prefix": "e6a3977bc33825e63abda15033cebb779ce4a756d2c0c67e293e63ca698fd198",
+        "size_in_bytes": 9310
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/unpacking.py",
+        "path_type": "hardlink",
+        "sha256": "fe055dcb34d10cc624b699d89639f83a8c6b653b4c09fe319274a6e2b2b459a0",
+        "sha256_in_prefix": "fe055dcb34d10cc624b699d89639f83a8c6b653b4c09fe319274a6e2b2b459a0",
+        "size_in_bytes": 11967
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/urls.py",
+        "path_type": "hardlink",
+        "sha256": "a9c7923996f995b343ac736cbfbfd2e0be18b6cce36b93703ca50c9d91db6273",
+        "sha256_in_prefix": "a9c7923996f995b343ac736cbfbfd2e0be18b6cce36b93703ca50c9d91db6273",
+        "size_in_bytes": 1599
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/virtualenv.py",
+        "path_type": "hardlink",
+        "sha256": "4ba7fb72c628ad1a620fa72f9f78c849961cdc8f0f242e371f988c1694401035",
+        "sha256_in_prefix": "4ba7fb72c628ad1a620fa72f9f78c849961cdc8f0f242e371f988c1694401035",
+        "size_in_bytes": 3456
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/utils/wheel.py",
+        "path_type": "hardlink",
+        "sha256": "6f8e368e4c9d1478d7cc3cba70c47b329cd6049d50f36851e45df77267075778",
+        "sha256_in_prefix": "6f8e368e4c9d1478d7cc3cba70c47b329cd6049d50f36851e45df77267075778",
+        "size_in_bytes": 4494
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "500aafce96e2d156d9a3751beac904799030fa8a08651fb35ff5a909bc720a85",
+        "sha256_in_prefix": "500aafce96e2d156d9a3751beac904799030fa8a08651fb35ff5a909bc720a85",
+        "size_in_bytes": 596
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de21fa952d68c43197c258346de8cf3d5b34bcc3ea31e04b32e4e7236118b57d",
+        "sha256_in_prefix": "de21fa952d68c43197c258346de8cf3d5b34bcc3ea31e04b32e4e7236118b57d",
+        "size_in_bytes": 463
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/__pycache__/bazaar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "93acfd713d1443fa94a071477ea757d77761825489ac96e16cf2698811290e5d",
+        "sha256_in_prefix": "93acfd713d1443fa94a071477ea757d77761825489ac96e16cf2698811290e5d",
+        "size_in_bytes": 3472
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/__pycache__/git.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c7cb16c99cbf924e5e11837fa24c8b2a8c6398aad80d1036cdce3814e13b9da5",
+        "sha256_in_prefix": "c7cb16c99cbf924e5e11837fa24c8b2a8c6398aad80d1036cdce3814e13b9da5",
+        "size_in_bytes": 12427
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/__pycache__/mercurial.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2b802238d0aac6e17eb10a1bf40bc955bbecb45507e5e2420ba075cb0777742a",
+        "sha256_in_prefix": "2b802238d0aac6e17eb10a1bf40bc955bbecb45507e5e2420ba075cb0777742a",
+        "size_in_bytes": 5021
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/__pycache__/subversion.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9b819cf3b1359997c10a7a69072cb6d6b6f3fb22cdaa8ee6b6a6383eb8c742b7",
+        "sha256_in_prefix": "9b819cf3b1359997c10a7a69072cb6d6b6f3fb22cdaa8ee6b6a6383eb8c742b7",
+        "size_in_bytes": 8450
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/__pycache__/versioncontrol.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "600481486299078973aee8dfd5e2d80813407eafe7ac6be5d337122b45ab4ef1",
+        "sha256_in_prefix": "600481486299078973aee8dfd5e2d80813407eafe7ac6be5d337122b45ab4ef1",
+        "size_in_bytes": 20978
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/bazaar.py",
+        "path_type": "hardlink",
+        "sha256": "10a4ad71068aa4dbb434ae29e50d7439ce316f70d4c45c34db85eb272e346c54",
+        "sha256_in_prefix": "10a4ad71068aa4dbb434ae29e50d7439ce316f70d4c45c34db85eb272e346c54",
+        "size_in_bytes": 3528
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/git.py",
+        "path_type": "hardlink",
+        "sha256": "deda5cf4b400fc9e08556e6be4dbd669a49e0f372624ead215937427cbc829f5",
+        "sha256_in_prefix": "deda5cf4b400fc9e08556e6be4dbd669a49e0f372624ead215937427cbc829f5",
+        "size_in_bytes": 18177
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/mercurial.py",
+        "path_type": "hardlink",
+        "sha256": "a142ce8732765227bed3a775a2690bfbf19cea6786694932a20bea1bd642c8fb",
+        "sha256_in_prefix": "a142ce8732765227bed3a775a2690bfbf19cea6786694932a20bea1bd642c8fb",
+        "size_in_bytes": 5249
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/subversion.py",
+        "path_type": "hardlink",
+        "sha256": "75d4ee80706a1f357779b2a55394171cf378814aa5c976cec7cabc3605cabecf",
+        "sha256_in_prefix": "75d4ee80706a1f357779b2a55394171cf378814aa5c976cec7cabc3605cabecf",
+        "size_in_bytes": 11735
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/vcs/versioncontrol.py",
+        "path_type": "hardlink",
+        "sha256": "72f7fffa19d302340b5c9dddd7b14c36141f70ed4070a594175d2d7eb6323fe7",
+        "sha256_in_prefix": "72f7fffa19d302340b5c9dddd7b14c36141f70ed4070a594175d2d7eb6323fe7",
+        "size_in_bytes": 22440
+      },
+      {
+        "_path": "Lib/site-packages/pip/_internal/wheel_builder.py",
+        "path_type": "hardlink",
+        "sha256": "0cbdc0f0b29e463fc00a9d75592e704a001280f16a7b201e5c929d5df99a5975",
+        "sha256_in_prefix": "0cbdc0f0b29e463fc00a9d75592e704a001280f16a7b201e5c929d5df99a5975",
+        "size_in_bytes": 11799
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "258b805ef0a58489f122b036153a79a7ebae5952fb595ebebc4a53b38ebe421e",
+        "sha256_in_prefix": "258b805ef0a58489f122b036153a79a7ebae5952fb595ebebc4a53b38ebe421e",
+        "size_in_bytes": 4873
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e0a36d168251a8271cf59fd1f41fc8c584f6afca686064221491aa04bd098449",
+        "sha256_in_prefix": "e0a36d168251a8271cf59fd1f41fc8c584f6afca686064221491aa04bd098449",
+        "size_in_bytes": 2999
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7628688f709ed9493e2acb809b2838da3a4f6904af873b7059a66f4d6c98c0f6",
+        "sha256_in_prefix": "7628688f709ed9493e2acb809b2838da3a4f6904af873b7059a66f4d6c98c0f6",
+        "size_in_bytes": 101741
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "2cc0b90817bde1944be71865cf0c8f0e61d7bc10f4a7b953e11dd9ef70fa6bf2",
+        "sha256_in_prefix": "2cc0b90817bde1944be71865cf0c8f0e61d7bc10f4a7b953e11dd9ef70fa6bf2",
+        "size_in_bytes": 677
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f70bce6fe7ad61c5dc105403416db5f995f69dbceb3be4ee69e8b50aad36be8b",
+        "sha256_in_prefix": "f70bce6fe7ad61c5dc105403416db5f995f69dbceb3be4ee69e8b50aad36be8b",
+        "size_in_bytes": 711
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3434b0c3817f9b4e66d24b1469f0c3030f851f7c7f8e4921a0d2e0d7796459b5",
+        "sha256_in_prefix": "3434b0c3817f9b4e66d24b1469f0c3030f851f7c7f8e4921a0d2e0d7796459b5",
+        "size_in_bytes": 1754
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a4a812954714e1e038f6b220914689defe0c2cad1c2f4696ca75c7b46770bf14",
+        "sha256_in_prefix": "a4a812954714e1e038f6b220914689defe0c2cad1c2f4696ca75c7b46770bf14",
+        "size_in_bytes": 4171
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/cache.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "34a5726cc7031f75291e146f6a80aa31fd075516d61d181964c6d7e7ada5a316",
+        "sha256_in_prefix": "34a5726cc7031f75291e146f6a80aa31fd075516d61d181964c6d7e7ada5a316",
+        "size_in_bytes": 3138
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "335f63737889a5cf093ec99872a98dbd1c1cfe1b315c0198a159cac26f1d104f",
+        "sha256_in_prefix": "335f63737889a5cf093ec99872a98dbd1c1cfe1b315c0198a159cac26f1d104f",
+        "size_in_bytes": 9923
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "170726b65e588e6fadbb38fb18fa5870ac7ea1f34d879465cd48403c0a24da59",
+        "sha256_in_prefix": "170726b65e588e6fadbb38fb18fa5870ac7ea1f34d879465cd48403c0a24da59",
+        "size_in_bytes": 3093
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dff1e727da2b946babc0e399f27f3d4783efcd08f1a11d63e75d95d86efa0d2a",
+        "sha256_in_prefix": "dff1e727da2b946babc0e399f27f3d4783efcd08f1a11d63e75d95d86efa0d2a",
+        "size_in_bytes": 5209
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/serialize.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5ec95afc1df81c85db3b8431a5c8b14b32fca2d7ca784c3fb9542b3c517ef10c",
+        "sha256_in_prefix": "5ec95afc1df81c85db3b8431a5c8b14b32fca2d7ca784c3fb9542b3c517ef10c",
+        "size_in_bytes": 3223
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bff652d868052ab81e04ec19803601a9ca643fcf4947e1ced698fa35e97416cb",
+        "sha256_in_prefix": "bff652d868052ab81e04ec19803601a9ca643fcf4947e1ced698fa35e97416cb",
+        "size_in_bytes": 1331
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/_cmd.py",
+        "path_type": "hardlink",
+        "sha256": "8a2b2dd84a7326f0d5221300c57abc8859d306c89901dea2a65c5f98d6e83729",
+        "sha256_in_prefix": "8a2b2dd84a7326f0d5221300c57abc8859d306c89901dea2a65c5f98d6e83729",
+        "size_in_bytes": 1737
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/adapter.py",
+        "path_type": "hardlink",
+        "sha256": "7de6e36382d5f3b8a20882b78dc97c887e7c89a480edbf56928bec0722032b46",
+        "sha256_in_prefix": "7de6e36382d5f3b8a20882b78dc97c887e7c89a480edbf56928bec0722032b46",
+        "size_in_bytes": 6348
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/cache.py",
+        "path_type": "hardlink",
+        "sha256": "397c2fec59f60309ca3626a12479e3b6f68a2e776f54bbfffb33be96d955f6a2",
+        "sha256_in_prefix": "397c2fec59f60309ca3626a12479e3b6f68a2e776f54bbfffb33be96d955f6a2",
+        "size_in_bytes": 1953
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/caches/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "76daebae82b90670034751968c2675f5a674b45b0c7ef141b4b410535b29fda8",
+        "sha256_in_prefix": "76daebae82b90670034751968c2675f5a674b45b0c7ef141b4b410535b29fda8",
+        "size_in_bytes": 303
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e9f096d4056fd26e0ece5f38ff39b314ee5838c671fbf0a66bb7d08920e6b27c",
+        "sha256_in_prefix": "e9f096d4056fd26e0ece5f38ff39b314ee5838c671fbf0a66bb7d08920e6b27c",
+        "size_in_bytes": 374
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "37f9aa225322e7b4d643ff036e36cde44dc03c82fd96112e71f1f90ef323f025",
+        "sha256_in_prefix": "37f9aa225322e7b4d643ff036e36cde44dc03c82fd96112e71f1f90ef323f025",
+        "size_in_bytes": 5333
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e16f7a35026a14d614cd1efb58ec2c46208300d92980ede497b55cc922d6f6bd",
+        "sha256_in_prefix": "e16f7a35026a14d614cd1efb58ec2c46208300d92980ede497b55cc922d6f6bd",
+        "size_in_bytes": 1921
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py",
+        "path_type": "hardlink",
+        "sha256": "6fba0c82c452a8f984b289d5270eae144614945803e8617c4f269c3861b5c773",
+        "sha256_in_prefix": "6fba0c82c452a8f984b289d5270eae144614945803e8617c4f269c3861b5c773",
+        "size_in_bytes": 5399
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py",
+        "path_type": "hardlink",
+        "sha256": "f6b9aac2d62efe58d5916ebfa0ba9b0bb11a5ff6bc613ff22ee9daf9e4b4760a",
+        "sha256_in_prefix": "f6b9aac2d62efe58d5916ebfa0ba9b0bb11a5ff6bc613ff22ee9daf9e4b4760a",
+        "size_in_bytes": 1386
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/controller.py",
+        "path_type": "hardlink",
+        "sha256": "8256cf8f6899946a9d060f33d3d0f60ed40ece83865e75afcbb2b62c4c81b044",
+        "sha256_in_prefix": "8256cf8f6899946a9d060f33d3d0f60ed40ece83865e75afcbb2b62c4c81b044",
+        "size_in_bytes": 18576
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/filewrapper.py",
+        "path_type": "hardlink",
+        "sha256": "da4b5734f1342aa9f2cc5db868eb0a080e7c1d0ab5c5e0ba97683aff3c238217",
+        "sha256_in_prefix": "da4b5734f1342aa9f2cc5db868eb0a080e7c1d0ab5c5e0ba97683aff3c238217",
+        "size_in_bytes": 4291
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/heuristics.py",
+        "path_type": "hardlink",
+        "sha256": "82a31753cc34810b8442249dbb7620fb4bddf645bb9eb58a6cb71aef9ae17861",
+        "sha256_in_prefix": "82a31753cc34810b8442249dbb7620fb4bddf645bb9eb58a6cb71aef9ae17861",
+        "size_in_bytes": 4881
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/serialize.py",
+        "path_type": "hardlink",
+        "sha256": "1d0776225950d391f33e454b3174c5dae5f99a31108c3064c42a94254383a599",
+        "sha256_in_prefix": "1d0776225950d391f33e454b3174c5dae5f99a31108c3064c42a94254383a599",
+        "size_in_bytes": 5163
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/cachecontrol/wrapper.py",
+        "path_type": "hardlink",
+        "sha256": "86c19cee0f101904d3fb87fcb60cf700ce6ac12720e853b405274b491744be95",
+        "sha256_in_prefix": "86c19cee0f101904d3fb87fcb60cf700ce6ac12720e853b405274b491744be95",
+        "size_in_bytes": 1417
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/certifi/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "a7f19866b8d4c0f0548692e5099a066f49a2281292a83032642e43bc8baa6c74",
+        "sha256_in_prefix": "a7f19866b8d4c0f0548692e5099a066f49a2281292a83032642e43bc8baa6c74",
+        "size_in_bytes": 94
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/certifi/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "d64dc2afde6f0b1c464460e58eb5b7c0c76965d2f73617f4bb59fe936a9db026",
+        "sha256_in_prefix": "d64dc2afde6f0b1c464460e58eb5b7c0c76965d2f73617f4bb59fe936a9db026",
+        "size_in_bytes": 255
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/certifi/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8b11440ec94021f3eab8f168dbe00b32e6e46c1056901d46e00f70ee33fc8d42",
+        "sha256_in_prefix": "8b11440ec94021f3eab8f168dbe00b32e6e46c1056901d46e00f70ee33fc8d42",
+        "size_in_bytes": 253
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/certifi/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "27c9069964df446a3c9343019c9d4538159a8f9ddb241d3ee6af6682d813e905",
+        "sha256_in_prefix": "27c9069964df446a3c9343019c9d4538159a8f9ddb241d3ee6af6682d813e905",
+        "size_in_bytes": 401
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/certifi/__pycache__/core.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "58fede0bee47cf5a10e0d0619d4e4fc38b1322b1c8d34ac88f43ccb13b743609",
+        "sha256_in_prefix": "58fede0bee47cf5a10e0d0619d4e4fc38b1322b1c8d34ac88f43ccb13b743609",
+        "size_in_bytes": 2091
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/certifi/cacert.pem",
+        "path_type": "hardlink",
+        "sha256": "94edeb66e91774fcae93a05650914e29096259a5c7e871a1f65d461ab5201b47",
+        "sha256_in_prefix": "94edeb66e91774fcae93a05650914e29096259a5c7e871a1f65d461ab5201b47",
+        "size_in_bytes": 299427
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/certifi/core.py",
+        "path_type": "hardlink",
+        "sha256": "d92453e6b21c4028450db7b7ec141afa450bc40809f2a37a9758dfa93a781c8b",
+        "sha256_in_prefix": "d92453e6b21c4028450db7b7ec141afa450bc40809f2a37a9758dfa93a781c8b",
+        "size_in_bytes": 4486
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/certifi/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "75cc2060660642a0046b00573c3b48c7cd033bfddc3a616ff074dcf093339274",
+        "sha256_in_prefix": "75cc2060660642a0046b00573c3b48c7cd033bfddc3a616ff074dcf093339274",
+        "size_in_bytes": 625
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5b412d4598b687435b11e5b867a19afac010925a21025581c3ceb54510acac7d",
+        "sha256_in_prefix": "5b412d4598b687435b11e5b867a19afac010925a21025581c3ceb54510acac7d",
+        "size_in_bytes": 1011
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/compat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "baa025c9e4db8302f375bc4adef2bfbd459efc7a23b6a3a74d4affe08ed9fe66",
+        "sha256_in_prefix": "baa025c9e4db8302f375bc4adef2bfbd459efc7a23b6a3a74d4affe08ed9fe66",
+        "size_in_bytes": 31681
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/database.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4c2d7b3910322c24175e61f17c18d1978be08d08e5ac4655d57cf46ba38b02f1",
+        "sha256_in_prefix": "4c2d7b3910322c24175e61f17c18d1978be08d08e5ac4655d57cf46ba38b02f1",
+        "size_in_bytes": 42879
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/index.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b0648146ad06d53db994a6b8937e521f34755b87dfb1ddae5467f596d3dc37df",
+        "sha256_in_prefix": "b0648146ad06d53db994a6b8937e521f34755b87dfb1ddae5467f596d3dc37df",
+        "size_in_bytes": 17222
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/locators.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "50d8c7bb1fc6348bf56a1114f729cb64d255bfecfd6a5bebd9ac113223af6c0e",
+        "sha256_in_prefix": "50d8c7bb1fc6348bf56a1114f729cb64d255bfecfd6a5bebd9ac113223af6c0e",
+        "size_in_bytes": 38075
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/manifest.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2cc5b8d406334bea76b9de3cb5d8ede204785277bc6b35ffaf91097e8487c48f",
+        "sha256_in_prefix": "2cc5b8d406334bea76b9de3cb5d8ede204785277bc6b35ffaf91097e8487c48f",
+        "size_in_bytes": 10138
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/markers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e306cfc0293775800c42a3664ab23e17ec136d7b45199ab902e8a308b12753d2",
+        "sha256_in_prefix": "e306cfc0293775800c42a3664ab23e17ec136d7b45199ab902e8a308b12753d2",
+        "size_in_bytes": 5264
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/metadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5255eb6ff27916fb102fd742e653ebcb4be6d7ade6b8884a88f75b3fd6928f0e",
+        "sha256_in_prefix": "5255eb6ff27916fb102fd742e653ebcb4be6d7ade6b8884a88f75b3fd6928f0e",
+        "size_in_bytes": 26910
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/resources.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1e166e2d2433356324ac162fb4d52e5e6250dd930044e1bf95c33f8d8e1e5efb",
+        "sha256_in_prefix": "1e166e2d2433356324ac162fb4d52e5e6250dd930044e1bf95c33f8d8e1e5efb",
+        "size_in_bytes": 10959
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "72402b5c4ebc054dc8cb1a0b27378013f0efd0e289bf9bac89b5fa9f8554eedf",
+        "sha256_in_prefix": "72402b5c4ebc054dc8cb1a0b27378013f0efd0e289bf9bac89b5fa9f8554eedf",
+        "size_in_bytes": 11598
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "31d42e11bc2bbc05eb541250b2c646b10dc6c060f478c58b6f0a04577f538351",
+        "sha256_in_prefix": "31d42e11bc2bbc05eb541250b2c646b10dc6c060f478c58b6f0a04577f538351",
+        "size_in_bytes": 51996
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c16e8c9b072babab286720a6e732a1d1d1e8e859d495f813964fefee6968edce",
+        "sha256_in_prefix": "c16e8c9b072babab286720a6e732a1d1d1e8e859d495f813964fefee6968edce",
+        "size_in_bytes": 20440
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/__pycache__/wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3b262698d1a7455c0a46883a602f2cc92aa5c882c4079d3c3d348073fdcf75f8",
+        "sha256_in_prefix": "3b262698d1a7455c0a46883a602f2cc92aa5c882c4079d3c3d348073fdcf75f8",
+        "size_in_bytes": 28256
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/compat.py",
+        "path_type": "hardlink",
+        "sha256": "da34528d1238a3ebe55de4cad8108621486473a7bd646852b1a711339a2c793c",
+        "sha256_in_prefix": "da34528d1238a3ebe55de4cad8108621486473a7bd646852b1a711339a2c793c",
+        "size_in_bytes": 41467
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/database.py",
+        "path_type": "hardlink",
+        "sha256": "987cbf2f189722c21545bf93d3e89d06b54bc3715f8a3e6d7870a96e3989f585",
+        "sha256_in_prefix": "987cbf2f189722c21545bf93d3e89d06b54bc3715f8a3e6d7870a96e3989f585",
+        "size_in_bytes": 51160
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/index.py",
+        "path_type": "hardlink",
+        "sha256": "9536f0dbaf2b4618fc770d6c89bdd567fd048521a0a093b714a27348530e69e0",
+        "sha256_in_prefix": "9536f0dbaf2b4618fc770d6c89bdd567fd048521a0a093b714a27348530e69e0",
+        "size_in_bytes": 20797
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/locators.py",
+        "path_type": "hardlink",
+        "sha256": "a0178066916e3d0498d3d3203672df4061805d7bd53bde8116967228cb8ae2d3",
+        "sha256_in_prefix": "a0178066916e3d0498d3d3203672df4061805d7bd53bde8116967228cb8ae2d3",
+        "size_in_bytes": 51026
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/manifest.py",
+        "path_type": "hardlink",
+        "sha256": "dea7e6026570c51a94d68db70257d7ad0199ce1ea0fc61b34c03ff1dbf42e734",
+        "sha256_in_prefix": "dea7e6026570c51a94d68db70257d7ad0199ce1ea0fc61b34c03ff1dbf42e734",
+        "size_in_bytes": 14168
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/markers.py",
+        "path_type": "hardlink",
+        "sha256": "5fab03be41467184bc8145bc85fb16b8a10a02a85064027b89738c2f14588d89",
+        "sha256_in_prefix": "5fab03be41467184bc8145bc85fb16b8a10a02a85064027b89738c2f14588d89",
+        "size_in_bytes": 5164
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/metadata.py",
+        "path_type": "hardlink",
+        "sha256": "ce2977b20d8451f2d75628258d8d9dff4dc826df894acee75feef77c408c5f6b",
+        "sha256_in_prefix": "ce2977b20d8451f2d75628258d8d9dff4dc826df894acee75feef77c408c5f6b",
+        "size_in_bytes": 38724
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/resources.py",
+        "path_type": "hardlink",
+        "sha256": "2f06cf92c73403524c6e2e979ee3dd301527f375fb04fb85356a8f184288ebdf",
+        "sha256_in_prefix": "2f06cf92c73403524c6e2e979ee3dd301527f375fb04fb85356a8f184288ebdf",
+        "size_in_bytes": 10820
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/scripts.py",
+        "path_type": "hardlink",
+        "sha256": "04996268301969507b580930a24802dc75f02c3da25a21da548e741fb0ba786f",
+        "sha256_in_prefix": "04996268301969507b580930a24802dc75f02c3da25a21da548e741fb0ba786f",
+        "size_in_bytes": 18608
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/t32.exe",
+        "path_type": "hardlink",
+        "sha256": "6b4195e640a85ac32eb6f9628822a622057df1e459df7c17a12f97aeabc9415b",
+        "sha256_in_prefix": "6b4195e640a85ac32eb6f9628822a622057df1e459df7c17a12f97aeabc9415b",
+        "size_in_bytes": 97792
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/t64-arm.exe",
+        "path_type": "hardlink",
+        "sha256": "ebc4c06b7d95e74e315419ee7e88e1d0f71e9e9477538c00a93a9ff8c66a6cfc",
+        "sha256_in_prefix": "ebc4c06b7d95e74e315419ee7e88e1d0f71e9e9477538c00a93a9ff8c66a6cfc",
+        "size_in_bytes": 182784
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/t64.exe",
+        "path_type": "hardlink",
+        "sha256": "81a618f21cb87db9076134e70388b6e9cb7c2106739011b6a51772d22cae06b7",
+        "sha256_in_prefix": "81a618f21cb87db9076134e70388b6e9cb7c2106739011b6a51772d22cae06b7",
+        "size_in_bytes": 108032
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/util.py",
+        "path_type": "hardlink",
+        "sha256": "bcc3c6bec4b88fd845e98f64dd3ca89b569a1cb6f4ac5999004cb378075e97dc",
+        "sha256_in_prefix": "bcc3c6bec4b88fd845e98f64dd3ca89b569a1cb6f4ac5999004cb378075e97dc",
+        "size_in_bytes": 66682
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/version.py",
+        "path_type": "hardlink",
+        "sha256": "b39548b3cc019f47f1cc6c5633f680d99672c79db91dc65b32f713953c99dd18",
+        "sha256_in_prefix": "b39548b3cc019f47f1cc6c5633f680d99672c79db91dc65b32f713953c99dd18",
+        "size_in_bytes": 23727
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/w32.exe",
+        "path_type": "hardlink",
+        "sha256": "47872cc77f8e18cf642f868f23340a468e537e64521d9a3a416c8b84384d064b",
+        "sha256_in_prefix": "47872cc77f8e18cf642f868f23340a468e537e64521d9a3a416c8b84384d064b",
+        "size_in_bytes": 91648
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/w64-arm.exe",
+        "path_type": "hardlink",
+        "sha256": "c5dc9884a8f458371550e09bd396e5418bf375820a31b9899f6499bf391c7b2e",
+        "sha256_in_prefix": "c5dc9884a8f458371550e09bd396e5418bf375820a31b9899f6499bf391c7b2e",
+        "size_in_bytes": 168448
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/w64.exe",
+        "path_type": "hardlink",
+        "sha256": "7a319ffaba23a017d7b1e18ba726ba6c54c53d6446db55f92af53c279894f8ad",
+        "sha256_in_prefix": "7a319ffaba23a017d7b1e18ba726ba6c54c53d6446db55f92af53c279894f8ad",
+        "size_in_bytes": 101888
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distlib/wheel.py",
+        "path_type": "hardlink",
+        "sha256": "0c521582e1101c27719d27403b475f16c80c72f5598ad83b6c23ae2f067b03fb",
+        "sha256_in_prefix": "0c521582e1101c27719d27403b475f16c80c72f5598ad83b6c23ae2f067b03fb",
+        "size_in_bytes": 43979
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distro/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "d9f1e317e49f80fbe3c8d67588787fc23a96751fd8a393831f0642d232c13e17",
+        "sha256_in_prefix": "d9f1e317e49f80fbe3c8d67588787fc23a96751fd8a393831f0642d232c13e17",
+        "size_in_bytes": 981
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distro/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "6eef5ddd389fa0a72264572a441bb2815dc64ae4e19d50ff9b620ae1ccfde95b",
+        "sha256_in_prefix": "6eef5ddd389fa0a72264572a441bb2815dc64ae4e19d50ff9b620ae1ccfde95b",
+        "size_in_bytes": 64
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distro/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9337e07d97ff825ac1d7451eca856afb976f1268427388fdfa1a83ea3c2338d7",
+        "sha256_in_prefix": "9337e07d97ff825ac1d7451eca856afb976f1268427388fdfa1a83ea3c2338d7",
+        "size_in_bytes": 864
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distro/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bbbb1ce26a2caaa7026ac70d19ab55179a15fd05fab81f6be3e53c53fb12f4cd",
+        "sha256_in_prefix": "bbbb1ce26a2caaa7026ac70d19ab55179a15fd05fab81f6be3e53c53fb12f4cd",
+        "size_in_bytes": 212
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distro/__pycache__/distro.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d8757dc04d42a44720805d6f569c78099e1b50e854a4ed84bf2e468e570d00e0",
+        "sha256_in_prefix": "d8757dc04d42a44720805d6f569c78099e1b50e854a4ed84bf2e468e570d00e0",
+        "size_in_bytes": 42311
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distro/distro.py",
+        "path_type": "hardlink",
+        "sha256": "5ea6de7da7008434f8cebfedae76c0d79798f2f74ae064e08609af506ac433fe",
+        "sha256_in_prefix": "5ea6de7da7008434f8cebfedae76c0d79798f2f74ae064e08609af506ac433fe",
+        "size_in_bytes": 49430
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/distro/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "30fa8d0cb65b5ea19a35d5f1005862a853ca1105e3bb68cd42109ecbafb97893",
+        "sha256_in_prefix": "30fa8d0cb65b5ea19a35d5f1005862a853ca1105e3bb68cd42109ecbafb97893",
+        "size_in_bytes": 868
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e6be544b8a96f458da6bdae9e03b4f0c0f3ae7fbe987936c77a0d3da14cded77",
+        "sha256_in_prefix": "e6be544b8a96f458da6bdae9e03b4f0c0f3ae7fbe987936c77a0d3da14cded77",
+        "size_in_bytes": 801
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/__pycache__/codec.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "950bc01a1469b06199fdc9b09a2cd2a5efa4c04ce6566005530cb8c7d3e50a97",
+        "sha256_in_prefix": "950bc01a1469b06199fdc9b09a2cd2a5efa4c04ce6566005530cb8c7d3e50a97",
+        "size_in_bytes": 3264
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/__pycache__/compat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e73d72404e0516f1be4b0094a8d4ff8ab10ccd06e6e54f9b83012575f9380963",
+        "sha256_in_prefix": "e73d72404e0516f1be4b0094a8d4ff8ab10ccd06e6e54f9b83012575f9380963",
+        "size_in_bytes": 723
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/__pycache__/core.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bb754a93252ae5d4adcfa4e68cc7ff2a91c9be2359ebb6b18c758b13f769d67a",
+        "sha256_in_prefix": "bb754a93252ae5d4adcfa4e68cc7ff2a91c9be2359ebb6b18c758b13f769d67a",
+        "size_in_bytes": 9822
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "04d1b8238d047acbbd4520d71d98fbe2fd85bde00bb617bd4819d61c485f7306",
+        "sha256_in_prefix": "04d1b8238d047acbbd4520d71d98fbe2fd85bde00bb617bd4819d61c485f7306",
+        "size_in_bytes": 42041
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/__pycache__/intranges.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7a2d0e390dfbeb6c6be387b45592df1be9e162dd8c06eff80e9790dd28946298",
+        "sha256_in_prefix": "7a2d0e390dfbeb6c6be387b45592df1be9e162dd8c06eff80e9790dd28946298",
+        "size_in_bytes": 1946
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/__pycache__/package_data.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "056c88b53c5409d197ffcf3b6412469d7adc84be8eb3bbe9ce2f7ddbc7c953f2",
+        "sha256_in_prefix": "056c88b53c5409d197ffcf3b6412469d7adc84be8eb3bbe9ce2f7ddbc7c953f2",
+        "size_in_bytes": 161
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d0c32c9037b469bec7e0de99fff17ab329a6d182be01f8508ba108e0207c369",
+        "sha256_in_prefix": "2d0c32c9037b469bec7e0de99fff17ab329a6d182be01f8508ba108e0207c369",
+        "size_in_bytes": 153133
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/codec.py",
+        "path_type": "hardlink",
+        "sha256": "3c47b0dc8b70ce35b887299b6ac9edcb6376397bcd7201c1f898eb06ec473d86",
+        "sha256_in_prefix": "3c47b0dc8b70ce35b887299b6ac9edcb6376397bcd7201c1f898eb06ec473d86",
+        "size_in_bytes": 3422
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/compat.py",
+        "path_type": "hardlink",
+        "sha256": "4732f2e90402765f7bf3868585bd845fd10a1822638343f73e294675e5d7731f",
+        "sha256_in_prefix": "4732f2e90402765f7bf3868585bd845fd10a1822638343f73e294675e5d7731f",
+        "size_in_bytes": 316
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/core.py",
+        "path_type": "hardlink",
+        "sha256": "60963200c9f089010f8d50b8f85aaefe9e0227ac8a2ae0c69a9a41350350a45b",
+        "sha256_in_prefix": "60963200c9f089010f8d50b8f85aaefe9e0227ac8a2ae0c69a9a41350350a45b",
+        "size_in_bytes": 13239
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/idnadata.py",
+        "path_type": "hardlink",
+        "sha256": "5b7d067081afb4e598c008d98f8663ba8b94bad0ba7df80dbb28c9cbb7d9fa5a",
+        "sha256_in_prefix": "5b7d067081afb4e598c008d98f8663ba8b94bad0ba7df80dbb28c9cbb7d9fa5a",
+        "size_in_bytes": 78306
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/intranges.py",
+        "path_type": "hardlink",
+        "sha256": "6a652d91d8587101bc66bf82a0c33f91545a731922bc2d568313756fadca29d5",
+        "sha256_in_prefix": "6a652d91d8587101bc66bf82a0c33f91545a731922bc2d568313756fadca29d5",
+        "size_in_bytes": 1898
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/package_data.py",
+        "path_type": "hardlink",
+        "sha256": "ab9f52dce5ec739548f23eaf483d2c18133293acd9e2f58544413cf3208960ab",
+        "sha256_in_prefix": "ab9f52dce5ec739548f23eaf483d2c18133293acd9e2f58544413cf3208960ab",
+        "size_in_bytes": 21
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/idna/uts46data.py",
+        "path_type": "hardlink",
+        "sha256": "aedf742bd278d20512c29a433c2ae18e08b9000ea958ceb974419149feab2213",
+        "sha256_in_prefix": "aedf742bd278d20512c29a433c2ae18e08b9000ea958ceb974419149feab2213",
+        "size_in_bytes": 239289
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/msgpack/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "ade45a88eb44cd28cf9ebed3a718e022f6df967e6957ae8586b89c02cd9e0be8",
+        "sha256_in_prefix": "ade45a88eb44cd28cf9ebed3a718e022f6df967e6957ae8586b89c02cd9e0be8",
+        "size_in_bytes": 1109
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/msgpack/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8606e2aa658396e07984d464cfab97f63fbf96af7a3de92492653f42b68865fb",
+        "sha256_in_prefix": "8606e2aa658396e07984d464cfab97f63fbf96af7a3de92492653f42b68865fb",
+        "size_in_bytes": 1333
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/msgpack/__pycache__/exceptions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "25240fc99c5911a4cd99fc75a53c08695d8a5cae22d7aed4f0a7c88642d30363",
+        "sha256_in_prefix": "25240fc99c5911a4cd99fc75a53c08695d8a5cae22d7aed4f0a7c88642d30363",
+        "size_in_bytes": 1801
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/msgpack/__pycache__/ext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8868694ab61344f8aacde151f96878043f2b6c17ed7af93eab32ef1015256af7",
+        "sha256_in_prefix": "8868694ab61344f8aacde151f96878043f2b6c17ed7af93eab32ef1015256af7",
+        "size_in_bytes": 6008
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/msgpack/__pycache__/fallback.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "64deed1a5e05aa5a9721462754e76edbe76ed85847c907610497b6be4d2e778b",
+        "sha256_in_prefix": "64deed1a5e05aa5a9721462754e76edbe76ed85847c907610497b6be4d2e778b",
+        "size_in_bytes": 23888
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/msgpack/exceptions.py",
+        "path_type": "hardlink",
+        "sha256": "7424d67a2f1da64accb100dc8d093be004e5f47b08047d326edf3338f36a3187",
+        "sha256_in_prefix": "7424d67a2f1da64accb100dc8d093be004e5f47b08047d326edf3338f36a3187",
+        "size_in_bytes": 1081
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/msgpack/ext.py",
+        "path_type": "hardlink",
+        "sha256": "92d789bf4de7f6d633779a28df1628a554e8e2f45a031a27050409857a21659a",
+        "sha256_in_prefix": "92d789bf4de7f6d633779a28df1628a554e8e2f45a031a27050409857a21659a",
+        "size_in_bytes": 5726
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/msgpack/fallback.py",
+        "path_type": "hardlink",
+        "sha256": "d20d4fce9d2fb66044989e70f45decffe24c55444ff114b81b571ce5345a02c2",
+        "sha256_in_prefix": "d20d4fce9d2fb66044989e70f45decffe24c55444ff114b81b571ce5345a02c2",
+        "size_in_bytes": 32390
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "764e136bfbe67552716070dc7f286f40dc3c5773e0481a2628d5ea83e0f62436",
+        "sha256_in_prefix": "764e136bfbe67552716070dc7f286f40dc3c5773e0481a2628d5ea83e0f62436",
+        "size_in_bytes": 494
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "592b8ef0361f4e4ca927d58c50a8d83a09ae182dbc4b70ebe774e69699eec002",
+        "sha256_in_prefix": "592b8ef0361f4e4ca927d58c50a8d83a09ae182dbc4b70ebe774e69699eec002",
+        "size_in_bytes": 472
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/_elffile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "96d8770932b77cc1bdb53c3dbf0e3cdaa9431947335af1d6f4eedc7cae53c069",
+        "sha256_in_prefix": "96d8770932b77cc1bdb53c3dbf0e3cdaa9431947335af1d6f4eedc7cae53c069",
+        "size_in_bytes": 3371
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/_manylinux.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8d47889ecd0fe91f8df467f52fe3801d96815d4e7bb90b9f2258ec0fc5596f1c",
+        "sha256_in_prefix": "8d47889ecd0fe91f8df467f52fe3801d96815d4e7bb90b9f2258ec0fc5596f1c",
+        "size_in_bytes": 6427
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/_musllinux.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "47da0c2bd3575bc7ce42d61971ecf21bc819383cf1f70c564dca2b7cb16886a3",
+        "sha256_in_prefix": "47da0c2bd3575bc7ce42d61971ecf21bc819383cf1f70c564dca2b7cb16886a3",
+        "size_in_bytes": 3336
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/_parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a652d9afb29678e3a5fce2ce6c0cb3ca44dfa350541c53c3fc7717c39f0e21fe",
+        "sha256_in_prefix": "a652d9afb29678e3a5fce2ce6c0cb3ca44dfa350541c53c3fc7717c39f0e21fe",
+        "size_in_bytes": 9046
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/_structures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9d59d4df0f1b87838df646e4fd5cec55cfc31c9a1f425cd1ed1dfda57d42efc2",
+        "sha256_in_prefix": "9d59d4df0f1b87838df646e4fd5cec55cfc31c9a1f425cd1ed1dfda57d42efc2",
+        "size_in_bytes": 2752
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/_tokenizer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b9021a94691f1ab1663369188c4cc06ad224ab3f246e0e04cbb238e9a84d3bf7",
+        "sha256_in_prefix": "b9021a94691f1ab1663369188c4cc06ad224ab3f246e0e04cbb238e9a84d3bf7",
+        "size_in_bytes": 5605
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/markers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dbafe6061360aba4fd6649206ba8579353941bc6c3398198a9692a5ce083d32e",
+        "sha256_in_prefix": "dbafe6061360aba4fd6649206ba8579353941bc6c3398198a9692a5ce083d32e",
+        "size_in_bytes": 7691
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/metadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c07699b4429cf3c1a5804236778d9212a8eff06d6fcf7f9bd22d0ee93e01e514",
+        "sha256_in_prefix": "c07699b4429cf3c1a5804236778d9212a8eff06d6fcf7f9bd22d0ee93e01e514",
+        "size_in_bytes": 18337
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/requirements.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1daaa2d2a6990b3117c4753585cf7b222e10c5ed27d2b74a0542fc0da230de1e",
+        "sha256_in_prefix": "1daaa2d2a6990b3117c4753585cf7b222e10c5ed27d2b74a0542fc0da230de1e",
+        "size_in_bytes": 2817
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/specifiers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7b55d424d6393a6b0fe0fdf3ccf97f4d3ed1cf886bd6e3e129179791464a14bf",
+        "sha256_in_prefix": "7b55d424d6393a6b0fe0fdf3ccf97f4d3ed1cf886bd6e3e129179791464a14bf",
+        "size_in_bytes": 31186
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/tags.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2bd02e8dff50dfa7a968f522f4a4a0fab03707d2c5a18a422623970ead030a1a",
+        "sha256_in_prefix": "2bd02e8dff50dfa7a968f522f4a4a0fab03707d2c5a18a422623970ead030a1a",
+        "size_in_bytes": 14885
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a56c71984c872bb6d9a60a7465892b6e221c705b165072d27b84b85d69259bd1",
+        "sha256_in_prefix": "a56c71984c872bb6d9a60a7465892b6e221c705b165072d27b84b85d69259bd1",
+        "size_in_bytes": 4560
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5f03522a3e2647ff349c73ba0afe7ea861802134e0fc73ae73b1f2810196e6bd",
+        "sha256_in_prefix": "5f03522a3e2647ff349c73ba0afe7ea861802134e0fc73ae73b1f2810196e6bd",
+        "size_in_bytes": 15044
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/_elffile.py",
+        "path_type": "hardlink",
+        "sha256": "71f940400904db9b738589aafda0a2ef641f6d3fed9fcf75b4fcdfa5b7873b01",
+        "sha256_in_prefix": "71f940400904db9b738589aafda0a2ef641f6d3fed9fcf75b4fcdfa5b7873b01",
+        "size_in_bytes": 3306
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/_manylinux.py",
+        "path_type": "hardlink",
+        "sha256": "be5e4e0a8cf8931f341f9af05ca7975a397d58d2121a6af86604e94cff6553d7",
+        "sha256_in_prefix": "be5e4e0a8cf8931f341f9af05ca7975a397d58d2121a6af86604e94cff6553d7",
+        "size_in_bytes": 9612
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/_musllinux.py",
+        "path_type": "hardlink",
+        "sha256": "a7d66a35888e22d19e7bc29c64578717f61c76157018774aeabfbc9608b1bc64",
+        "sha256_in_prefix": "a7d66a35888e22d19e7bc29c64578717f61c76157018774aeabfbc9608b1bc64",
+        "size_in_bytes": 2694
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/_parser.py",
+        "path_type": "hardlink",
+        "sha256": "b3f4ef4ef0cd2b436b336401dd529385d58533835cd0fe899e439b925dcc8e93",
+        "sha256_in_prefix": "b3f4ef4ef0cd2b436b336401dd529385d58533835cd0fe899e439b925dcc8e93",
+        "size_in_bytes": 10236
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/_structures.py",
+        "path_type": "hardlink",
+        "sha256": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe",
+        "sha256_in_prefix": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe",
+        "size_in_bytes": 1431
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/_tokenizer.py",
+        "path_type": "hardlink",
+        "sha256": "27abf91fb273bdbfa0f35c69ff640008ac0eecbc47400ea292bc8c53bcd7c0df",
+        "sha256_in_prefix": "27abf91fb273bdbfa0f35c69ff640008ac0eecbc47400ea292bc8c53bcd7c0df",
+        "size_in_bytes": 5273
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/licenses/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "035d7af85538f7f0f3e35eb6338cb5b8089937846075cf3717135df048e57ea2",
+        "sha256_in_prefix": "035d7af85538f7f0f3e35eb6338cb5b8089937846075cf3717135df048e57ea2",
+        "size_in_bytes": 5727
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/licenses/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dfa8fcfc877a712e11a011ef1be4e5f8d42f97880d212a97c8fc1e011aba6ed1",
+        "sha256_in_prefix": "dfa8fcfc877a712e11a011ef1be4e5f8d42f97880d212a97c8fc1e011aba6ed1",
+        "size_in_bytes": 2571
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/licenses/__pycache__/_spdx.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3b12857af0052b38fbf1e3f3db6905bc9eebbb265989f9e1120d42d7e2db4aab",
+        "sha256_in_prefix": "3b12857af0052b38fbf1e3f3db6905bc9eebbb265989f9e1120d42d7e2db4aab",
+        "size_in_bytes": 29575
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/licenses/_spdx.py",
+        "path_type": "hardlink",
+        "sha256": "a009b5ced3c5c25b2608a7bb94002cbff38839f4b57160eef5b34191ebbeda7b",
+        "sha256_in_prefix": "a009b5ced3c5c25b2608a7bb94002cbff38839f4b57160eef5b34191ebbeda7b",
+        "size_in_bytes": 48398
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/markers.py",
+        "path_type": "hardlink",
+        "sha256": "73cf5337307b65d198864a2f9ba3d89aa1b21f15e561568b5b9f753c750d283f",
+        "sha256_in_prefix": "73cf5337307b65d198864a2f9ba3d89aa1b21f15e561568b5b9f753c750d283f",
+        "size_in_bytes": 10561
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/metadata.py",
+        "path_type": "hardlink",
+        "sha256": "60989b33b1987b8adef3ed1adce9579864be5c38131283b8b6506ddaadb90678",
+        "sha256_in_prefix": "60989b33b1987b8adef3ed1adce9579864be5c38131283b8b6506ddaadb90678",
+        "size_in_bytes": 34762
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/requirements.py",
+        "path_type": "hardlink",
+        "sha256": "818c9148075bac8c8a0d8ebaba02035108d132fc641f600b8a84e65f7b672faa",
+        "sha256_in_prefix": "818c9148075bac8c8a0d8ebaba02035108d132fc641f600b8a84e65f7b672faa",
+        "size_in_bytes": 2947
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/specifiers.py",
+        "path_type": "hardlink",
+        "sha256": "84653a92e09defb6cbfa6b082fac8b0a9e8c353ef94523142990ee8eedba73c5",
+        "sha256_in_prefix": "84653a92e09defb6cbfa6b082fac8b0a9e8c353ef94523142990ee8eedba73c5",
+        "size_in_bytes": 40098
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/tags.py",
+        "path_type": "hardlink",
+        "sha256": "085aab2730337365cd19ec5eac7fff4fe639230abb59bb185ec88b1112d6c58d",
+        "sha256_in_prefix": "085aab2730337365cd19ec5eac7fff4fe639230abb59bb185ec88b1112d6c58d",
+        "size_in_bytes": 21014
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/utils.py",
+        "path_type": "hardlink",
+        "sha256": "d05dc787d385b9182b8538066549792b6d85bf560fdad665d73ff680eea42620",
+        "sha256_in_prefix": "d05dc787d385b9182b8538066549792b6d85bf560fdad665d73ff680eea42620",
+        "size_in_bytes": 5050
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/packaging/version.py",
+        "path_type": "hardlink",
+        "sha256": "a221eacd352ffe9d768698e0b0b0d571a179853ee90da48e56250d303e064d6d",
+        "sha256_in_prefix": "a221eacd352ffe9d768698e0b0b0d571a179853ee90da48e56250d303e064d6d",
+        "size_in_bytes": 16688
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pkg_resources/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "8eb84345b3ae6cfef842e3d7c5ded4ecfa38d8f1f697e2d9d977dc3bb965a59e",
+        "sha256_in_prefix": "8eb84345b3ae6cfef842e3d7c5ded4ecfa38d8f1f697e2d9d977dc3bb965a59e",
+        "size_in_bytes": 124463
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "46909168632f33441c763b36b7292bb0410fd7ec3905147734a4edb4d065c5ed",
+        "sha256_in_prefix": "46909168632f33441c763b36b7292bb0410fd7ec3905147734a4edb4d065c5ed",
+        "size_in_bytes": 112364
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "26e791d9c44b93163b8b08a4faa356242c0a3ab025060560719fc81d0cea18b1",
+        "sha256_in_prefix": "26e791d9c44b93163b8b08a4faa356242c0a3ab025060560719fc81d0cea18b1",
+        "size_in_bytes": 22344
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "8c127ccdbecca71e5e6dca85f37c6ba4ef7831a782a4d18755ff5cbc337624b8",
+        "sha256_in_prefix": "8c127ccdbecca71e5e6dca85f37c6ba4ef7831a782a4d18755ff5cbc337624b8",
+        "size_in_bytes": 1505
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3c41498fbee1195ef1cbb6d0f8da509f7b2c91db0b9c421edf766213c8304bd9",
+        "sha256_in_prefix": "3c41498fbee1195ef1cbb6d0f8da509f7b2c91db0b9c421edf766213c8304bd9",
+        "size_in_bytes": 16471
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8a0719014fb3ccdc03ebafb7e660eab3421d93b6cac2430c13af137c71cca7c9",
+        "sha256_in_prefix": "8a0719014fb3ccdc03ebafb7e660eab3421d93b6cac2430c13af137c71cca7c9",
+        "size_in_bytes": 1338
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9441a1722dfb1aec4258f9fa6b39a4b8117727bc1903f58c3571725bb7e0959b",
+        "sha256_in_prefix": "9441a1722dfb1aec4258f9fa6b39a4b8117727bc1903f58c3571725bb7e0959b",
+        "size_in_bytes": 7921
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d8a27c1fc8f002ffc284a74adba47e5807867a316b63c51ac1e5a5d6ddd68848",
+        "sha256_in_prefix": "d8a27c1fc8f002ffc284a74adba47e5807867a316b63c51ac1e5a5d6ddd68848",
+        "size_in_bytes": 10576
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ce2495eab2a627d38ba37bf7dbcf18b2a882c6e3d3267f7f9eccfe5e0376151d",
+        "sha256_in_prefix": "ce2495eab2a627d38ba37bf7dbcf18b2a882c6e3d3267f7f9eccfe5e0376151d",
+        "size_in_bytes": 6778
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f2f1241c812ff029fa35e70070f54a0d95a069c45db7cffbdf979a5d33d63e8c",
+        "sha256_in_prefix": "f2f1241c812ff029fa35e70070f54a0d95a069c45db7cffbdf979a5d33d63e8c",
+        "size_in_bytes": 10810
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd1465165d5b256d4c7b3b25c307a2d5bbb82fc38edcc3fe7dcecdbaf3d37bfc",
+        "sha256_in_prefix": "dd1465165d5b256d4c7b3b25c307a2d5bbb82fc38edcc3fe7dcecdbaf3d37bfc",
+        "size_in_bytes": 467
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "43b87d113a6474f98324e3a43e458a9b20f1b1ef73b1d3a5a51b6cab12c47a47",
+        "sha256_in_prefix": "43b87d113a6474f98324e3a43e458a9b20f1b1ef73b1d3a5a51b6cab12c47a47",
+        "size_in_bytes": 9194
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/android.py",
+        "path_type": "hardlink",
+        "sha256": "915e682f75770d9e9664abbdc85890ba9bf5f32a7f8e5495d82847d5398f71db",
+        "sha256_in_prefix": "915e682f75770d9e9664abbdc85890ba9bf5f32a7f8e5495d82847d5398f71db",
+        "size_in_bytes": 9007
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/api.py",
+        "path_type": "hardlink",
+        "sha256": "d9d7d40cd6c45de0e10ca6abaad479358ee852291467845986cde8cecb668414",
+        "sha256_in_prefix": "d9d7d40cd6c45de0e10ca6abaad479358ee852291467845986cde8cecb668414",
+        "size_in_bytes": 9246
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/macos.py",
+        "path_type": "hardlink",
+        "sha256": "5256f2159f11ceedf19dd0aa4041eb7ec613787c187456a9d48a33fb2c6f793e",
+        "sha256_in_prefix": "5256f2159f11ceedf19dd0aa4041eb7ec613787c187456a9d48a33fb2c6f793e",
+        "size_in_bytes": 6154
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/unix.py",
+        "path_type": "hardlink",
+        "sha256": "b913c9591c9012dbfbc8e4af53de2b526b1b968e572832c0d52cc5839e646cad",
+        "sha256_in_prefix": "b913c9591c9012dbfbc8e4af53de2b526b1b968e572832c0d52cc5839e646cad",
+        "size_in_bytes": 10393
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/version.py",
+        "path_type": "hardlink",
+        "sha256": "a07e0a8137cae009256d3615715ff2ca7bc9f492c8de9caf0d56b2d2146c2c2b",
+        "sha256_in_prefix": "a07e0a8137cae009256d3615715ff2ca7bc9f492c8de9caf0d56b2d2146c2c2b",
+        "size_in_bytes": 411
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/platformdirs/windows.py",
+        "path_type": "hardlink",
+        "sha256": "205a62a21501c313ed0b39722b036dc725b8264f2169ae96f28e7d99fac35d5a",
+        "sha256_in_prefix": "205a62a21501c313ed0b39722b036dc725b8264f2169ae96f28e7d99fac35d5a",
+        "size_in_bytes": 10125
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "ecdd6889a5ae970fe70ac4d8e04122c582f3d79a56639bb8b8f005162fa27a55",
+        "sha256_in_prefix": "ecdd6889a5ae970fe70ac4d8e04122c582f3d79a56639bb8b8f005162fa27a55",
+        "size_in_bytes": 2983
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "8ac2210712e0eb99cb957ba41b856432e3df35d77b805cd367f47fcf743c7626",
+        "sha256_in_prefix": "8ac2210712e0eb99cb957ba41b856432e3df35d77b805cd367f47fcf743c7626",
+        "size_in_bytes": 353
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a0a325dbc36928c21b3403531568f361038d05b58030a5e61862062483c1165f",
+        "sha256_in_prefix": "a0a325dbc36928c21b3403531568f361038d05b58030a5e61862062483c1165f",
+        "size_in_bytes": 2898
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "657b77fbbe5b7cc52962d045519f8b6c69cae53ddfbddb87650b72e76651fd7e",
+        "sha256_in_prefix": "657b77fbbe5b7cc52962d045519f8b6c69cae53ddfbddb87650b72e76651fd7e",
+        "size_in_bytes": 535
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/cmdline.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "918b7b72e480e509b150a349e1cb374043e3d867d3d905ae7d477d674b30066c",
+        "sha256_in_prefix": "918b7b72e480e509b150a349e1cb374043e3d867d3d905ae7d477d674b30066c",
+        "size_in_bytes": 15430
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/console.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3f3a4ebad06c545ba5d1cb81172705a0b46ae891e3ab96036cd2ba9216b31704",
+        "sha256_in_prefix": "3f3a4ebad06c545ba5d1cb81172705a0b46ae891e3ab96036cd2ba9216b31704",
+        "size_in_bytes": 1839
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/filter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2f8be700ca46b324bf930243dbfc780b5d5a85d58cfe3ef13c80cf7d9804f5e5",
+        "sha256_in_prefix": "2f8be700ca46b324bf930243dbfc780b5d5a85d58cfe3ef13c80cf7d9804f5e5",
+        "size_in_bytes": 2589
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/formatter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c8b4ccbf7697a1b13fcbbd8827eb25fb381341580019d7412267bdb7c72bffa7",
+        "sha256_in_prefix": "c8b4ccbf7697a1b13fcbbd8827eb25fb381341580019d7412267bdb7c72bffa7",
+        "size_in_bytes": 4048
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/lexer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c1a2a8998fe5b8bdc3bcaf3e9620a05f15c14ce9a25354ef1a7dbc3304bcf010",
+        "sha256_in_prefix": "c1a2a8998fe5b8bdc3bcaf3e9620a05f15c14ce9a25354ef1a7dbc3304bcf010",
+        "size_in_bytes": 26679
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/modeline.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2f42685c72d33005ce025d2d9fbcd39c4143ae131dea16e25ce3781b2efeece2",
+        "sha256_in_prefix": "2f42685c72d33005ce025d2d9fbcd39c4143ae131dea16e25ce3781b2efeece2",
+        "size_in_bytes": 1136
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/plugin.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a34dd978e8b5f047775dfb20c4198c778151dec951f447a4370562b9f946a939",
+        "sha256_in_prefix": "a34dd978e8b5f047775dfb20c4198c778151dec951f447a4370562b9f946a939",
+        "size_in_bytes": 1966
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/regexopt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3781da096a02b9132b3075b4c97d324d850571d587a1c8942a52238d122582a9",
+        "sha256_in_prefix": "3781da096a02b9132b3075b4c97d324d850571d587a1c8942a52238d122582a9",
+        "size_in_bytes": 2889
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/scanner.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d06a1e3ba1a7a7fa2d49166a8ee4a764b055e46e44e429e6c67caebbec0f255",
+        "sha256_in_prefix": "2d06a1e3ba1a7a7fa2d49166a8ee4a764b055e46e44e429e6c67caebbec0f255",
+        "size_in_bytes": 3503
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/sphinxext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "831af1dc79b441478ffec1c8dc1be9ad61ae9f223a223cdf0820c40e640723f3",
+        "sha256_in_prefix": "831af1dc79b441478ffec1c8dc1be9ad61ae9f223a223cdf0820c40e640723f3",
+        "size_in_bytes": 7740
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/style.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "093f89c03b37aaf17446b7d2466bbdcaf8ac1a38cf0a2d54b419e8427e1c86c7",
+        "sha256_in_prefix": "093f89c03b37aaf17446b7d2466bbdcaf8ac1a38cf0a2d54b419e8427e1c86c7",
+        "size_in_bytes": 4479
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/token.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c3bb8757fdd62689f88f0c6ff53b4c862f9934364c7efca57b533d03a3aa7264",
+        "sha256_in_prefix": "c3bb8757fdd62689f88f0c6ff53b4c862f9934364c7efca57b533d03a3aa7264",
+        "size_in_bytes": 4351
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/unistring.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "942ac001588d236d5008689a96c8a5bb05b362a5ec097719b2cbbd189b7994c9",
+        "sha256_in_prefix": "942ac001588d236d5008689a96c8a5bb05b362a5ec097719b2cbbd189b7994c9",
+        "size_in_bytes": 31189
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e412d76bdc11a0173178b65d8fe42aaeb76dbc6be8b5dd03bb04ed843704bbba",
+        "sha256_in_prefix": "e412d76bdc11a0173178b65d8fe42aaeb76dbc6be8b5dd03bb04ed843704bbba",
+        "size_in_bytes": 10044
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/cmdline.py",
+        "path_type": "hardlink",
+        "sha256": "2c8573980ba7964f6c449269e783b8291cbd18320de16bb5deff69f50cdf18f3",
+        "sha256_in_prefix": "2c8573980ba7964f6c449269e783b8291cbd18320de16bb5deff69f50cdf18f3",
+        "size_in_bytes": 23656
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/console.py",
+        "path_type": "hardlink",
+        "sha256": "ca13fd52c2c056658a5507f6e38e8925ec2403b0225de7937f821e8373a2d9f5",
+        "sha256_in_prefix": "ca13fd52c2c056658a5507f6e38e8925ec2403b0225de7937f821e8373a2d9f5",
+        "size_in_bytes": 1718
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/filter.py",
+        "path_type": "hardlink",
+        "sha256": "fc00cd3c2b240fcfc69a87478bafcba1580f537661df7e9a0424f970e79332cd",
+        "sha256_in_prefix": "fc00cd3c2b240fcfc69a87478bafcba1580f537661df7e9a0424f970e79332cd",
+        "size_in_bytes": 1910
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/filters/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "45d79d2b629629794ac11edcbe47ebdcd523f588994203208a544c1548368cf0",
+        "sha256_in_prefix": "45d79d2b629629794ac11edcbe47ebdcd523f588994203208a544c1548368cf0",
+        "size_in_bytes": 40392
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/filters/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aa3ce50b15290f9ea9e6dc9d5b21ea01307c2dca17be1b0bd9294206290588d8",
+        "sha256_in_prefix": "aa3ce50b15290f9ea9e6dc9d5b21ea01307c2dca17be1b0bd9294206290588d8",
+        "size_in_bytes": 23451
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatter.py",
+        "path_type": "hardlink",
+        "sha256": "8c35814e7765047d99e486191550e73f4aa7d426934234d6b7b8801ad0a72448",
+        "sha256_in_prefix": "8c35814e7765047d99e486191550e73f4aa7d426934234d6b7b8801ad0a72448",
+        "size_in_bytes": 4390
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "f0da3e354b3cac14d2481248bf8852110b76334705078870013d2c9d57364061",
+        "sha256_in_prefix": "f0da3e354b3cac14d2481248bf8852110b76334705078870013d2c9d57364061",
+        "size_in_bytes": 5385
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f7cd91e1b476d021a17d1829cc9c9fd6a61287b42746b5afef1d114913c40512",
+        "sha256_in_prefix": "f7cd91e1b476d021a17d1829cc9c9fd6a61287b42746b5afef1d114913c40512",
+        "size_in_bytes": 4961
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b06b510f801b1d6f6a3cfa4fa64543c25e0dd576c3ac86ac05fbd1b0cae6dee6",
+        "sha256_in_prefix": "b06b510f801b1d6f6a3cfa4fa64543c25e0dd576c3ac86ac05fbd1b0cae6dee6",
+        "size_in_bytes": 3843
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c1a699b6a76d15fb8544c253ec96211c694af5f1d05d4c3f99ae7f1797902a29",
+        "sha256_in_prefix": "c1a699b6a76d15fb8544c253ec96211c694af5f1d05d4c3f99ae7f1797902a29",
+        "size_in_bytes": 3024
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/groff.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5e0e294bfbdbb040d6cac489e6f8e324d45214742472a803a392bbfea8c0e5d4",
+        "sha256_in_prefix": "5e0e294bfbdbb040d6cac489e6f8e324d45214742472a803a392bbfea8c0e5d4",
+        "size_in_bytes": 4341
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/html.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "098ed3c88afe6fac0499e456592595c4b785fd053090881b7bf7bc0de32f6550",
+        "sha256_in_prefix": "098ed3c88afe6fac0499e456592595c4b785fd053090881b7bf7bc0de32f6550",
+        "size_in_bytes": 29313
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/img.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "23da9cd233d443f665d3a783006fbc2c553988748004e5725a3e8a5232628acb",
+        "sha256_in_prefix": "23da9cd233d443f665d3a783006fbc2c553988748004e5725a3e8a5232628acb",
+        "size_in_bytes": 18349
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/irc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b28e9ba23b369e54be17215e8501b0837c991d1f0c20350e20639c8e3d767f7c",
+        "sha256_in_prefix": "b28e9ba23b369e54be17215e8501b0837c991d1f0c20350e20639c8e3d767f7c",
+        "size_in_bytes": 3869
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/latex.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "45b5769d8275a90710f482e3524b3cc75e536b23a88b86c6b717ba70dd6c32b8",
+        "sha256_in_prefix": "45b5769d8275a90710f482e3524b3cc75e536b23a88b86c6b717ba70dd6c32b8",
+        "size_in_bytes": 13831
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/other.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "454f081279df77d5c8bd92932f712dab9759320cb7bca7e0a19d1bb872d74543",
+        "sha256_in_prefix": "454f081279df77d5c8bd92932f712dab9759320cb7bca7e0a19d1bb872d74543",
+        "size_in_bytes": 4743
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5d621568444c50ad0932a67fe60c936b4ac21b5c58f69c05bb8361986deb41d9",
+        "sha256_in_prefix": "5d621568444c50ad0932a67fe60c936b4ac21b5c58f69c05bb8361986deb41d9",
+        "size_in_bytes": 2049
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "841a7be9fdadb916eb8f2cb294b2abadf74df1ad612da86e334a94cbd1f2d870",
+        "sha256_in_prefix": "841a7be9fdadb916eb8f2cb294b2abadf74df1ad612da86e334a94cbd1f2d870",
+        "size_in_bytes": 8803
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/svg.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a3a8d6809e160c2a6af9489e7ee00439a1f7581712e8342e4d921ab77f232e41",
+        "sha256_in_prefix": "a3a8d6809e160c2a6af9489e7ee00439a1f7581712e8342e4d921ab77f232e41",
+        "size_in_bytes": 6270
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "97129b3eee64fa36f3e79ce880fbfc6abc6bfc86a330da438b3ecbff83883250",
+        "sha256_in_prefix": "97129b3eee64fa36f3e79ce880fbfc6abc6bfc86a330da438b3ecbff83883250",
+        "size_in_bytes": 3854
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2b4a30c19f4e4bed9c817b11568e5fb293142948718ee2b68aeb0300a636ab68",
+        "sha256_in_prefix": "2b4a30c19f4e4bed9c817b11568e5fb293142948718ee2b68aeb0300a636ab68",
+        "size_in_bytes": 9164
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/_mapping.py",
+        "path_type": "hardlink",
+        "sha256": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e",
+        "sha256_in_prefix": "d42c37ec5b9094d69c9f144a9ad94f5f89f22e85fdfedb64a39670b1c354659e",
+        "size_in_bytes": 4176
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/bbcode.py",
+        "path_type": "hardlink",
+        "sha256": "dc940b238e6d72b43f91150c8ee69be82ec76f45d4b1b556aaa6d29fd70c8e42",
+        "sha256_in_prefix": "dc940b238e6d72b43f91150c8ee69be82ec76f45d4b1b556aaa6d29fd70c8e42",
+        "size_in_bytes": 3320
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/groff.py",
+        "path_type": "hardlink",
+        "sha256": "337f64d0f692499467c568ea05254f905d26bb5f95afb6e6e91b05becf8234de",
+        "sha256_in_prefix": "337f64d0f692499467c568ea05254f905d26bb5f95afb6e6e91b05becf8234de",
+        "size_in_bytes": 5106
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/html.py",
+        "path_type": "hardlink",
+        "sha256": "484da3737602a9b312deb656f440260e501485d571279da003876295e12f0865",
+        "sha256_in_prefix": "484da3737602a9b312deb656f440260e501485d571279da003876295e12f0865",
+        "size_in_bytes": 35669
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/img.py",
+        "path_type": "hardlink",
+        "sha256": "330038c563cb3b087a8fb61cea81f38eea923edd0cd5f879afee414c82147ec5",
+        "sha256_in_prefix": "330038c563cb3b087a8fb61cea81f38eea923edd0cd5f879afee414c82147ec5",
+        "size_in_bytes": 23287
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/irc.py",
+        "path_type": "hardlink",
+        "sha256": "769d59d25fce6c9e4d161f4c86a2c6839a6d1b986026a79d4f6564badb7dbf43",
+        "sha256_in_prefix": "769d59d25fce6c9e4d161f4c86a2c6839a6d1b986026a79d4f6564badb7dbf43",
+        "size_in_bytes": 4981
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/latex.py",
+        "path_type": "hardlink",
+        "sha256": "5cc9a1382a94283050b46e66189340158c40a6a682e69ba8e5c3263df2b7f78e",
+        "sha256_in_prefix": "5cc9a1382a94283050b46e66189340158c40a6a682e69ba8e5c3263df2b7f78e",
+        "size_in_bytes": 19306
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/other.py",
+        "path_type": "hardlink",
+        "sha256": "e7a3cc24e9628a7fab01476744cd22d70b15d467543ddfddbd0ab4fd43df17d7",
+        "sha256_in_prefix": "e7a3cc24e9628a7fab01476744cd22d70b15d467543ddfddbd0ab4fd43df17d7",
+        "size_in_bytes": 5034
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/pangomarkup.py",
+        "path_type": "hardlink",
+        "sha256": "cb5e94d34695618105a5e09f19795805231a706e36e426dfa06f2829b29e8088",
+        "sha256_in_prefix": "cb5e94d34695618105a5e09f19795805231a706e36e426dfa06f2829b29e8088",
+        "size_in_bytes": 2218
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/rtf.py",
+        "path_type": "hardlink",
+        "sha256": "653f7476670ac896e8201d2602b84bec8844e3aec65d13741bb4005201b4dd3a",
+        "sha256_in_prefix": "653f7476670ac896e8201d2602b84bec8844e3aec65d13741bb4005201b4dd3a",
+        "size_in_bytes": 11957
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/svg.py",
+        "path_type": "hardlink",
+        "sha256": "28ab22a2984fba91eec66d12a3e32c6d0116393e7820089217b8593e6c6d2971",
+        "sha256_in_prefix": "28ab22a2984fba91eec66d12a3e32c6d0116393e7820089217b8593e6c6d2971",
+        "size_in_bytes": 7174
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/terminal.py",
+        "path_type": "hardlink",
+        "sha256": "0288cd1b83252aad8be88b02fd59d71eee006c70819fd3ada20eaee395efc5e2",
+        "sha256_in_prefix": "0288cd1b83252aad8be88b02fd59d71eee006c70819fd3ada20eaee395efc5e2",
+        "size_in_bytes": 4674
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/formatters/terminal256.py",
+        "path_type": "hardlink",
+        "sha256": "90690d515a37169c23cad2034b489fefd12e528ae8029adc5adde282b708a93d",
+        "sha256_in_prefix": "90690d515a37169c23cad2034b489fefd12e528ae8029adc5adde282b708a93d",
+        "size_in_bytes": 11753
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/lexer.py",
+        "path_type": "hardlink",
+        "sha256": "4d81c3b7ffff80d5b86b14e5db3bcf65f7fe5508bc7cf68887938a45c5528d43",
+        "sha256_in_prefix": "4d81c3b7ffff80d5b86b14e5db3bcf65f7fe5508bc7cf68887938a45c5528d43",
+        "size_in_bytes": 35349
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/lexers/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "a48971c9026ebbfb3287d944d3cd1cabc71e55b11570aa74a2c0055397dac095",
+        "sha256_in_prefix": "a48971c9026ebbfb3287d944d3cd1cabc71e55b11570aa74a2c0055397dac095",
+        "size_in_bytes": 12115
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/lexers/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e199d193b74b18839962fdc30f25451dddb9495980b0cc73c7f12dc0db48276a",
+        "sha256_in_prefix": "e199d193b74b18839962fdc30f25451dddb9495980b0cc73c7f12dc0db48276a",
+        "size_in_bytes": 9961
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/lexers/__pycache__/_mapping.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d17ad40c2d958e95d7e2eea95231f77b98b359a0a7247cd4190758712b0d8b1a",
+        "sha256_in_prefix": "d17ad40c2d958e95d7e2eea95231f77b98b359a0a7247cd4190758712b0d8b1a",
+        "size_in_bytes": 55920
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/lexers/__pycache__/python.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eabdfde0adbc6ab2b5becbdc480afb10750ff613f2a53a1ca610b6fd564c76d7",
+        "sha256_in_prefix": "eabdfde0adbc6ab2b5becbdc480afb10750ff613f2a53a1ca610b6fd564c76d7",
+        "size_in_bytes": 29568
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/lexers/_mapping.py",
+        "path_type": "hardlink",
+        "sha256": "eb5fa1df3af5d379b4d4e4b9054abf01f5222fd608d3a55eb3d8a943b938bebe",
+        "sha256_in_prefix": "eb5fa1df3af5d379b4d4e4b9054abf01f5222fd608d3a55eb3d8a943b938bebe",
+        "size_in_bytes": 76097
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/lexers/python.py",
+        "path_type": "hardlink",
+        "sha256": "d89fd826b3d3aff03a7c963fa8a88abf41a980fc0732b94c49ea39f6a3777dee",
+        "sha256_in_prefix": "d89fd826b3d3aff03a7c963fa8a88abf41a980fc0732b94c49ea39f6a3777dee",
+        "size_in_bytes": 53687
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/modeline.py",
+        "path_type": "hardlink",
+        "sha256": "82d4586414be08a3820d71e1199a80a5ba0705a670187f20ce73773ba9eec63e",
+        "sha256_in_prefix": "82d4586414be08a3820d71e1199a80a5ba0705a670187f20ce73773ba9eec63e",
+        "size_in_bytes": 1005
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/plugin.py",
+        "path_type": "hardlink",
+        "sha256": "8a8789dd07a827e510859a58f492fbbdbc6c4d5bb0c0cec10aef896fc9cdd005",
+        "sha256_in_prefix": "8a8789dd07a827e510859a58f492fbbdbc6c4d5bb0c0cec10aef896fc9cdd005",
+        "size_in_bytes": 1891
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/regexopt.py",
+        "path_type": "hardlink",
+        "sha256": "1e4cb8101d77ac85c41d050d930982ad8aad2259d70de84d477333b5a7d9e37c",
+        "sha256_in_prefix": "1e4cb8101d77ac85c41d050d930982ad8aad2259d70de84d477333b5a7d9e37c",
+        "size_in_bytes": 3072
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/scanner.py",
+        "path_type": "hardlink",
+        "sha256": "343cb7a1f2bf7c74452b88480efc696a61bcef569ec2a72c21beac8138bb1619",
+        "sha256_in_prefix": "343cb7a1f2bf7c74452b88480efc696a61bcef569ec2a72c21beac8138bb1619",
+        "size_in_bytes": 3092
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/sphinxext.py",
+        "path_type": "hardlink",
+        "sha256": "88ea6d24172a3863f0304276a7bd0fbf0a593c819dbdd67c771beaea4cf10e00",
+        "sha256_in_prefix": "88ea6d24172a3863f0304276a7bd0fbf0a593c819dbdd67c771beaea4cf10e00",
+        "size_in_bytes": 7981
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/style.py",
+        "path_type": "hardlink",
+        "sha256": "ad2099585a60d7f0f014c5c35349c456601c047a6e4067fd471bce3cf42f28b4",
+        "sha256_in_prefix": "ad2099585a60d7f0f014c5c35349c456601c047a6e4067fd471bce3cf42f28b4",
+        "size_in_bytes": 6420
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/styles/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "a9493aff5cf92a64fc11d2456588044a61ba3ff1c917fdaf56b0c3ec74821986",
+        "sha256_in_prefix": "a9493aff5cf92a64fc11d2456588044a61ba3ff1c917fdaf56b0c3ec74821986",
+        "size_in_bytes": 2042
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/styles/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7547c91dcb5d796c43f6a861f82dc986d22064d8d94403cd9edf5d1ffe5a834a",
+        "sha256_in_prefix": "7547c91dcb5d796c43f6a861f82dc986d22064d8d94403cd9edf5d1ffe5a834a",
+        "size_in_bytes": 2007
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/styles/__pycache__/_mapping.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c209c117f9c667b9f8ca5ed20605c2d1a91d8e27b8b1b7ad7ba082fb34e220d7",
+        "sha256_in_prefix": "c209c117f9c667b9f8ca5ed20605c2d1a91d8e27b8b1b7ad7ba082fb34e220d7",
+        "size_in_bytes": 3047
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/styles/_mapping.py",
+        "path_type": "hardlink",
+        "sha256": "ea5a2f154136f6dcfa12c5775d8638860a3327bab524bedc7cedd43a58274bcc",
+        "sha256_in_prefix": "ea5a2f154136f6dcfa12c5775d8638860a3327bab524bedc7cedd43a58274bcc",
+        "size_in_bytes": 3312
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/token.py",
+        "path_type": "hardlink",
+        "sha256": "a99c13ecb48fcb96016372600e3badeb8d820b2ec9750cc07e6a83f4d993e63d",
+        "sha256_in_prefix": "a99c13ecb48fcb96016372600e3badeb8d820b2ec9750cc07e6a83f4d993e63d",
+        "size_in_bytes": 6226
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/unistring.py",
+        "path_type": "hardlink",
+        "sha256": "a797358be1e1a088567a6cbd094b1a37da37f68a266073715e59745dfc3ab440",
+        "sha256_in_prefix": "a797358be1e1a088567a6cbd094b1a37da37f68a266073715e59745dfc3ab440",
+        "size_in_bytes": 63208
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pygments/util.py",
+        "path_type": "hardlink",
+        "sha256": "dad8f69d2d57f7f3a972e4a37fc74e113d9b0d5661b3c70429dfee4faf85820f",
+        "sha256_in_prefix": "dad8f69d2d57f7f3a972e4a37fc74e113d9b0d5661b3c70429dfee4faf85820f",
+        "size_in_bytes": 10031
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pyproject_hooks/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "70f07f6bd2d7cf9c6fb116d7d68daac807632dab5925d43f2dce4c70d5fe5fb6",
+        "sha256_in_prefix": "70f07f6bd2d7cf9c6fb116d7d68daac807632dab5925d43f2dce4c70d5fe5fb6",
+        "size_in_bytes": 691
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pyproject_hooks/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "563e19bebdc250f281749f343b6e157b240f0eda48e4474f16e52ab1805b28d5",
+        "sha256_in_prefix": "563e19bebdc250f281749f343b6e157b240f0eda48e4474f16e52ab1805b28d5",
+        "size_in_bytes": 643
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pyproject_hooks/__pycache__/_impl.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f67d75d55e97a1b265759d53e9019e9ce16f1d3a25047a82caefa1b716c2c9db",
+        "sha256_in_prefix": "f67d75d55e97a1b265759d53e9019e9ce16f1d3a25047a82caefa1b716c2c9db",
+        "size_in_bytes": 14033
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pyproject_hooks/_impl.py",
+        "path_type": "hardlink",
+        "sha256": "8d8fab6b19e6c91c81e7baee022b6b25153311ec6e021193a6033282ac7aed9e",
+        "sha256_in_prefix": "8d8fab6b19e6c91c81e7baee022b6b25153311ec6e021193a6033282ac7aed9e",
+        "size_in_bytes": 14936
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pyproject_hooks/_in_process/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "30934fa5f23170ef85821c6905bc641b5ac58907fa1ce51b5785399aad07167b",
+        "sha256_in_prefix": "30934fa5f23170ef85821c6905bc641b5ac58907fa1ce51b5785399aad07167b",
+        "size_in_bytes": 557
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d42ccb49d0a7b52e422f1a34aad931a9dbf3aae20fbac5a1d6c23547fefa2a72",
+        "sha256_in_prefix": "d42ccb49d0a7b52e422f1a34aad931a9dbf3aae20fbac5a1d6c23547fefa2a72",
+        "size_in_bytes": 769
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pyproject_hooks/_in_process/__pycache__/_in_process.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "47f123ffb3591157fe15d27121f1fc6e141b643917b5e41f6f2d77065145f138",
+        "sha256_in_prefix": "47f123ffb3591157fe15d27121f1fc6e141b643917b5e41f6f2d77065145f138",
+        "size_in_bytes": 10593
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pyproject_hooks/_in_process/_in_process.py",
+        "path_type": "hardlink",
+        "sha256": "a9c5cc866c7ffcc209ab5d201875b7980e1397c772f18cc731c7309cda0a970d",
+        "sha256_in_prefix": "a9c5cc866c7ffcc209ab5d201875b7980e1397c772f18cc731c7309cda0a970d",
+        "size_in_bytes": 12216
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/pyproject_hooks/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "1e507f1f386bcc6b5f0ff69a614c14875cd65cb67be7f6022f28adef9774573f",
+        "sha256_in_prefix": "1e507f1f386bcc6b5f0ff69a614c14875cd65cb67be7f6022f28adef9774573f",
+        "size_in_bytes": 5057
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b4113e064428b28e4cd20a5a17fbdd1b8034011daec4068a2cc98287f4feee2c",
+        "sha256_in_prefix": "b4113e064428b28e4cd20a5a17fbdd1b8034011daec4068a2cc98287f4feee2c",
+        "size_in_bytes": 3801
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/__version__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "79df8ad6f0383a559a7d2cd1e2c07b5b653c0c4786a5b8bea368c8f184bbe3d9",
+        "sha256_in_prefix": "79df8ad6f0383a559a7d2cd1e2c07b5b653c0c4786a5b8bea368c8f184bbe3d9",
+        "size_in_bytes": 499
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/_internal_utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "608a730bba6d6dff93e25960419a0ad074caa52b20555a8eeb2113cb6e53b7aa",
+        "sha256_in_prefix": "608a730bba6d6dff93e25960419a0ad074caa52b20555a8eeb2113cb6e53b7aa",
+        "size_in_bytes": 1574
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/adapters.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dbe057298b2b42765e256b672c8e6991c194bb937b66bbe5019c9756870d3b52",
+        "sha256_in_prefix": "dbe057298b2b42765e256b672c8e6991c194bb937b66bbe5019c9756870d3b52",
+        "size_in_bytes": 22058
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/api.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "164e25dc1a91315b5428c422c295377a79da669c3f0281c88be3f52350431567",
+        "sha256_in_prefix": "164e25dc1a91315b5428c422c295377a79da669c3f0281c88be3f52350431567",
+        "size_in_bytes": 6740
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/auth.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "19b6f77f3f02e4c396d4717fc9d68e66cfa5bc13f0c70e4d562377e6bc995d3b",
+        "sha256_in_prefix": "19b6f77f3f02e4c396d4717fc9d68e66cfa5bc13f0c70e4d562377e6bc995d3b",
+        "size_in_bytes": 8305
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/certs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2740a68730fa11aef89eecc348a8c8750847500a1b1004feb74754687927ec42",
+        "sha256_in_prefix": "2740a68730fa11aef89eecc348a8c8750847500a1b1004feb74754687927ec42",
+        "size_in_bytes": 582
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/compat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "813cc57d842a39b98937ea527036d72609213d9bdbc0e0b105b8bcf218c55590",
+        "sha256_in_prefix": "813cc57d842a39b98937ea527036d72609213d9bdbc0e0b105b8bcf218c55590",
+        "size_in_bytes": 1467
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/cookies.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1ee8cbf2216ce1e3dee6ded45883601a44291937c9e929152f93a3e0e7217278",
+        "sha256_in_prefix": "1ee8cbf2216ce1e3dee6ded45883601a44291937c9e929152f93a3e0e7217278",
+        "size_in_bytes": 18797
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/exceptions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e9d471de57ffae985fe37b34ca2312fa6e4defc0e543d27336f9fdb683a5f36c",
+        "sha256_in_prefix": "e9d471de57ffae985fe37b34ca2312fa6e4defc0e543d27336f9fdb683a5f36c",
+        "size_in_bytes": 6580
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/help.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a1007a7a9bacd886a046777e67709e6dcec20b3dac08fcfb72db797ca97266fe",
+        "sha256_in_prefix": "a1007a7a9bacd886a046777e67709e6dcec20b3dac08fcfb72db797ca97266fe",
+        "size_in_bytes": 2753
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/hooks.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4a6ea4f14fe3ae62060f6a799c6e894dedb1563bd299f68b3370d923c8cdbba3",
+        "sha256_in_prefix": "4a6ea4f14fe3ae62060f6a799c6e894dedb1563bd299f68b3370d923c8cdbba3",
+        "size_in_bytes": 939
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/models.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "27449a2704b7dfcb77eafb6b4e306c8153da6aad7d2e64552fba0acc1bf0c1e6",
+        "sha256_in_prefix": "27449a2704b7dfcb77eafb6b4e306c8153da6aad7d2e64552fba0acc1bf0c1e6",
+        "size_in_bytes": 24285
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/packages.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dab9f7b9495b089e1852752944cfad1ea395dda43b2f39023b9d54a49c4351f7",
+        "sha256_in_prefix": "dab9f7b9495b089e1852752944cfad1ea395dda43b2f39023b9d54a49c4351f7",
+        "size_in_bytes": 675
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/sessions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c73c8a230860f4a142bbc923b987052395147c886bbabf19902c6af426de5977",
+        "sha256_in_prefix": "c73c8a230860f4a142bbc923b987052395147c886bbabf19902c6af426de5977",
+        "size_in_bytes": 19730
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/status_codes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9a3eeb036106e9b7e335303db04b3fca7da59e37f9c52fed0df490ed7fe43afd",
+        "sha256_in_prefix": "9a3eeb036106e9b7e335303db04b3fca7da59e37f9c52fed0df490ed7fe43afd",
+        "size_in_bytes": 4255
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/structures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e082105eb8fee9389541f0a9899080f57d2959dbc4ce26f4034cd6f35d78ab7f",
+        "sha256_in_prefix": "e082105eb8fee9389541f0a9899080f57d2959dbc4ce26f4034cd6f35d78ab7f",
+        "size_in_bytes": 4396
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__pycache__/utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "491fc09c2799acb7a72942e0dcbd856be81b0e36f4a1b5e17428ea6ade1cedac",
+        "sha256_in_prefix": "491fc09c2799acb7a72942e0dcbd856be81b0e36f4a1b5e17428ea6ade1cedac",
+        "size_in_bytes": 24484
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/__version__.py",
+        "path_type": "hardlink",
+        "sha256": "1557e09606663509e660f5e93a8843539f05e4451bffe5674936807ac4b5f3b8",
+        "sha256_in_prefix": "1557e09606663509e660f5e93a8843539f05e4451bffe5674936807ac4b5f3b8",
+        "size_in_bytes": 435
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/_internal_utils.py",
+        "path_type": "hardlink",
+        "sha256": "9cc4329abe21b37d93a95a3901b0ab99c24486f3d487bc57965bb2ab0b252e24",
+        "sha256_in_prefix": "9cc4329abe21b37d93a95a3901b0ab99c24486f3d487bc57965bb2ab0b252e24",
+        "size_in_bytes": 1495
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/adapters.py",
+        "path_type": "hardlink",
+        "sha256": "27b55e571281bdac1bb655f60c4455a34e49f415d371660b30735dd4169af9b9",
+        "sha256_in_prefix": "27b55e571281bdac1bb655f60c4455a34e49f415d371660b30735dd4169af9b9",
+        "size_in_bytes": 27607
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/api.py",
+        "path_type": "hardlink",
+        "sha256": "fd96fd39aeedcd5222cd32b016b3e30c463d7a3b66fce9d2444467003c46b10b",
+        "sha256_in_prefix": "fd96fd39aeedcd5222cd32b016b3e30c463d7a3b66fce9d2444467003c46b10b",
+        "size_in_bytes": 6449
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/auth.py",
+        "path_type": "hardlink",
+        "sha256": "905ef9b6a9cb72d67d31ffe19bd4d9223e1c4169cde6ec51cfca16b31e70991d",
+        "sha256_in_prefix": "905ef9b6a9cb72d67d31ffe19bd4d9223e1c4169cde6ec51cfca16b31e70991d",
+        "size_in_bytes": 10186
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/certs.py",
+        "path_type": "hardlink",
+        "sha256": "9070e590afdb7ae1d778c3dce63b5adb0825f2074a7945ade5fda74c356bbedf",
+        "sha256_in_prefix": "9070e590afdb7ae1d778c3dce63b5adb0825f2074a7945ade5fda74c356bbedf",
+        "size_in_bytes": 441
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/compat.py",
+        "path_type": "hardlink",
+        "sha256": "328f5ff7166979fa1df199be9fdfd2b497154e6c12ba45d1da9dc8432c955ef5",
+        "sha256_in_prefix": "328f5ff7166979fa1df199be9fdfd2b497154e6c12ba45d1da9dc8432c955ef5",
+        "size_in_bytes": 1485
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/cookies.py",
+        "path_type": "hardlink",
+        "sha256": "6cd8be8aa123e0d3d9d34fa86feac7bf392f39bccdde5129830de0ea9692dd7c",
+        "sha256_in_prefix": "6cd8be8aa123e0d3d9d34fa86feac7bf392f39bccdde5129830de0ea9692dd7c",
+        "size_in_bytes": 18590
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/exceptions.py",
+        "path_type": "hardlink",
+        "sha256": "0f5c2acd85a77b5992dab538ded3fd09e3751bb400cbb7aa2fda3582877a123c",
+        "sha256_in_prefix": "0f5c2acd85a77b5992dab538ded3fd09e3751bb400cbb7aa2fda3582877a123c",
+        "size_in_bytes": 4272
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/help.py",
+        "path_type": "hardlink",
+        "sha256": "85129a7fdbb41bb7ddc2ba8c1ed177a06d7a44a92d45fe8a8b0b52ab6168d7fd",
+        "sha256_in_prefix": "85129a7fdbb41bb7ddc2ba8c1ed177a06d7a44a92d45fe8a8b0b52ab6168d7fd",
+        "size_in_bytes": 3813
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/hooks.py",
+        "path_type": "hardlink",
+        "sha256": "0a2bb2b221c0dfd57951f702057148c7cdc8ac3a6ec1f37d45c4d482fdbc7ed4",
+        "sha256_in_prefix": "0a2bb2b221c0dfd57951f702057148c7cdc8ac3a6ec1f37d45c4d482fdbc7ed4",
+        "size_in_bytes": 733
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/models.py",
+        "path_type": "hardlink",
+        "sha256": "c782b80a61fe942d25d8a6fe88f7cc3787515f11c471b39a11604bfe2d3d0302",
+        "sha256_in_prefix": "c782b80a61fe942d25d8a6fe88f7cc3787515f11c471b39a11604bfe2d3d0302",
+        "size_in_bytes": 35483
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/packages.py",
+        "path_type": "hardlink",
+        "sha256": "fd94030894c9f123f79155ae9d2a81b1164d3f38f673558556a6ddaf4f29cf75",
+        "sha256_in_prefix": "fd94030894c9f123f79155ae9d2a81b1164d3f38f673558556a6ddaf4f29cf75",
+        "size_in_bytes": 1057
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/sessions.py",
+        "path_type": "hardlink",
+        "sha256": "ca44c8f145864a5b4e7c7d3b1caa25947ee44c11b0e168620556901a67244f0e",
+        "sha256_in_prefix": "ca44c8f145864a5b4e7c7d3b1caa25947ee44c11b0e168620556901a67244f0e",
+        "size_in_bytes": 30495
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/status_codes.py",
+        "path_type": "hardlink",
+        "sha256": "889500780db96da4ddc3ee8f7c3d1e178aa1a48343251248fb268cab1b382c42",
+        "sha256_in_prefix": "889500780db96da4ddc3ee8f7c3d1e178aa1a48343251248fb268cab1b382c42",
+        "size_in_bytes": 4322
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/structures.py",
+        "path_type": "hardlink",
+        "sha256": "f886e6855cf4e92fb968f499b94b6167afba0fd5ce8d1b935c739a6d8d38d573",
+        "sha256_in_prefix": "f886e6855cf4e92fb968f499b94b6167afba0fd5ce8d1b935c739a6d8d38d573",
+        "size_in_bytes": 2912
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/requests/utils.py",
+        "path_type": "hardlink",
+        "sha256": "2fbf6f9c56f32774852cab49c29a167b8d53a338b746566ff78a58d53148ca8c",
+        "sha256_in_prefix": "2fbf6f9c56f32774852cab49c29a167b8d53a338b746566ff78a58d53148ca8c",
+        "size_in_bytes": 33631
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "879d3d4dd11ca5be7ee382689da5377b1d93335e465412e333d08d08fc274d3b",
+        "sha256_in_prefix": "879d3d4dd11ca5be7ee382689da5377b1d93335e465412e333d08d08fc274d3b",
+        "size_in_bytes": 537
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "142ae77072e1b4b7f5ff97eec4e20adabe894e1b1633fd47efc58a106ea09f68",
+        "sha256_in_prefix": "142ae77072e1b4b7f5ff97eec4e20adabe894e1b1633fd47efc58a106ea09f68",
+        "size_in_bytes": 555
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/providers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "571960d15f0ad302bd401511a1dee22b7a6940d87b7989fc8af61b08ef2be47b",
+        "sha256_in_prefix": "571960d15f0ad302bd401511a1dee22b7a6940d87b7989fc8af61b08ef2be47b",
+        "size_in_bytes": 6653
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/reporters.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ced927f5a655dabe09f0e3ee6600b09e3608c38a9834989a307e8348ab2b8c7f",
+        "sha256_in_prefix": "ced927f5a655dabe09f0e3ee6600b09e3608c38a9834989a307e8348ab2b8c7f",
+        "size_in_bytes": 2598
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/resolvers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2b9972ea1bc03657ad11b60eea32da721b69cd444bdee26e9164069d9663bdd3",
+        "sha256_in_prefix": "2b9972ea1bc03657ad11b60eea32da721b69cd444bdee26e9164069d9663bdd3",
+        "size_in_bytes": 17584
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/__pycache__/structs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2deaff73ea98a03693bfa789398a6014998a4e717564abc76e80ae09b39cfe41",
+        "sha256_in_prefix": "2deaff73ea98a03693bfa789398a6014998a4e717564abc76e80ae09b39cfe41",
+        "size_in_bytes": 7318
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/compat/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cfee8331466fe559ed97e33747fd515030a25bfd1cf629f6a481553f2c7518ff",
+        "sha256_in_prefix": "cfee8331466fe559ed97e33747fd515030a25bfd1cf629f6a481553f2c7518ff",
+        "size_in_bytes": 150
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7c044287e4079beefeea94b33a73152e6588e9a2f9d49b483de9c415b5d9980e",
+        "sha256_in_prefix": "7c044287e4079beefeea94b33a73152e6588e9a2f9d49b483de9c415b5d9980e",
+        "size_in_bytes": 324
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/compat/collections_abc.py",
+        "path_type": "hardlink",
+        "sha256": "bb2f31519f8d0c4c3dd7ab6e8145e6f0783008688c3b47fe45c767a647d77ceb",
+        "sha256_in_prefix": "bb2f31519f8d0c4c3dd7ab6e8145e6f0783008688c3b47fe45c767a647d77ceb",
+        "size_in_bytes": 156
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/providers.py",
+        "path_type": "hardlink",
+        "sha256": "7eebaf56b09eb6ee60b313c1e37111ca37cef1a45e4b7ac5407a4382222d6ece",
+        "sha256_in_prefix": "7eebaf56b09eb6ee60b313c1e37111ca37cef1a45e4b7ac5407a4382222d6ece",
+        "size_in_bytes": 5871
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/reporters.py",
+        "path_type": "hardlink",
+        "sha256": "4d26d1996cd3736eb0d2082c5756f15697960c1f10348adeeadc1897b1886411",
+        "sha256_in_prefix": "4d26d1996cd3736eb0d2082c5756f15697960c1f10348adeeadc1897b1886411",
+        "size_in_bytes": 1601
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/resolvers.py",
+        "path_type": "hardlink",
+        "sha256": "1bcaec2d94aaeb883956622afa507b51c209d608c0c48409993178444665790d",
+        "sha256_in_prefix": "1bcaec2d94aaeb883956622afa507b51c209d608c0c48409993178444665790d",
+        "size_in_bytes": 20511
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/resolvelib/structs.py",
+        "path_type": "hardlink",
+        "sha256": "d3fd7f5cef33fc22e17a03f75697fd549df325c7cb9b434e1d133e8b4624cf7a",
+        "sha256_in_prefix": "d3fd7f5cef33fc22e17a03f75697fd549df325c7cb9b434e1d133e8b4624cf7a",
+        "size_in_bytes": 4963
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "751c6320bf926c5558d2adc88d232b7e00531eb9b52d90e02ceca0541c226197",
+        "sha256_in_prefix": "751c6320bf926c5558d2adc88d232b7e00531eb9b52d90e02ceca0541c226197",
+        "size_in_bytes": 6090
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "78eec2abc267ae01bccd5a1e226880b3ddaade15cd3087e9d30e6532c3bb4366",
+        "sha256_in_prefix": "78eec2abc267ae01bccd5a1e226880b3ddaade15cd3087e9d30e6532c3bb4366",
+        "size_in_bytes": 8477
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "beb9bd0ec1c27e677a99269df34ef62da63699f5de932edba239f9184fd5f937",
+        "sha256_in_prefix": "beb9bd0ec1c27e677a99269df34ef62da63699f5de932edba239f9184fd5f937",
+        "size_in_bytes": 5968
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "93ece3c934cfb92e2624fd571bde54e75bfabcb09e79ea5117894beafaf018c7",
+        "sha256_in_prefix": "93ece3c934cfb92e2624fd571bde54e75bfabcb09e79ea5117894beafaf018c7",
+        "size_in_bytes": 7096
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_cell_widths.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "186204883267910a2d7811f949223e144b4b6267b4be479c66339fe4c20dca22",
+        "sha256_in_prefix": "186204883267910a2d7811f949223e144b4b6267b4be479c66339fe4c20dca22",
+        "size_in_bytes": 7814
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5a2c5c1c162f17b04035bcbce6c7cefc91ba78d31b833239b533b7da0de82b6c",
+        "sha256_in_prefix": "5a2c5c1c162f17b04035bcbce6c7cefc91ba78d31b833239b533b7da0de82b6c",
+        "size_in_bytes": 132650
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_emoji_replace.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "258f8215b98f6453bff2a97eacff9af6a837dc7bf62c71ce118f8ea2f6b5440b",
+        "sha256_in_prefix": "258f8215b98f6453bff2a97eacff9af6a837dc7bf62c71ce118f8ea2f6b5440b",
+        "size_in_bytes": 1135
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_export_format.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2dfde1cb8f8d8698265cf1c9923dc4518a1ff6f4cab1b139232f4dc5e0067d57",
+        "sha256_in_prefix": "2dfde1cb8f8d8698265cf1c9923dc4518a1ff6f4cab1b139232f4dc5e0067d57",
+        "size_in_bytes": 2274
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_extension.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "369ef445df5657cdfd881941ecc24941c69a0a685826df47f7b164391d2f702d",
+        "sha256_in_prefix": "369ef445df5657cdfd881941ecc24941c69a0a685826df47f7b164391d2f702d",
+        "size_in_bytes": 444
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_fileno.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8bfa38f574f76a9db368295cd17ccf3068b5809cae631f7dedc9f76e4f20e55b",
+        "sha256_in_prefix": "8bfa38f574f76a9db368295cd17ccf3068b5809cae631f7dedc9f76e4f20e55b",
+        "size_in_bytes": 721
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_inspect.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7f8ceb406c3ab1007a06f43fe8451f5cb28d429a0ddf341db6434957e0ef70ed",
+        "sha256_in_prefix": "7f8ceb406c3ab1007a06f43fe8451f5cb28d429a0ddf341db6434957e0ef70ed",
+        "size_in_bytes": 8588
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_log_render.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5c3ee7353866aad6193ff92a853d23e8d06f0ea21551dbcd461df0b95e024d56",
+        "sha256_in_prefix": "5c3ee7353866aad6193ff92a853d23e8d06f0ea21551dbcd461df0b95e024d56",
+        "size_in_bytes": 2527
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_loop.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "63a24d92fd5440e31916d5d8abfd4a56d9671bf71aaf0bf3f76a4a6598b04a5d",
+        "sha256_in_prefix": "63a24d92fd5440e31916d5d8abfd4a56d9671bf71aaf0bf3f76a4a6598b04a5d",
+        "size_in_bytes": 1217
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_null_file.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a0447e68ae13aa428472bbdba019b0bd2d74b9165b014bc1f255fbafee6dd630",
+        "sha256_in_prefix": "a0447e68ae13aa428472bbdba019b0bd2d74b9165b014bc1f255fbafee6dd630",
+        "size_in_bytes": 3334
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_palettes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "95f752f9d031984d9d9c66a16559f7ac27987ad57df8a85503b7d17c2fe5c783",
+        "sha256_in_prefix": "95f752f9d031984d9d9c66a16559f7ac27987ad57df8a85503b7d17c2fe5c783",
+        "size_in_bytes": 5046
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_pick.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fa798cdeddde9993842ff528a45865cc3c80bd23ed7f9282e504b312ae869083",
+        "sha256_in_prefix": "fa798cdeddde9993842ff528a45865cc3c80bd23ed7f9282e504b312ae869083",
+        "size_in_bytes": 587
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_ratio.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "980181746e785fbbe52883c18fba4087a7ed9e06344d2270b80d1f416ca21e1c",
+        "sha256_in_prefix": "980181746e785fbbe52883c18fba4087a7ed9e06344d2270b80d1f416ca21e1c",
+        "size_in_bytes": 5071
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_spinners.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c7beed1de7e9881fad3a76f0f19719a8436d875861479aaf0c7448d401410328",
+        "sha256_in_prefix": "c7beed1de7e9881fad3a76f0f19719a8436d875861479aaf0c7448d401410328",
+        "size_in_bytes": 11543
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_stack.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6da5ee9aab98e52f473f1855a3d4844182cef4287bae238dccb04a21bd457598",
+        "sha256_in_prefix": "6da5ee9aab98e52f473f1855a3d4844182cef4287bae238dccb04a21bd457598",
+        "size_in_bytes": 792
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_timer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1a176b2eaae39ba7dc3a3f53a71ae1e5e748b220dc2cf150e0aeedf6bb7d9c34",
+        "sha256_in_prefix": "1a176b2eaae39ba7dc3a3f53a71ae1e5e748b220dc2cf150e0aeedf6bb7d9c34",
+        "size_in_bytes": 639
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_win32_console.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "823c2ddfd8e275ba31ba2469ce37b419da9aa0d9b799a3e9d7f3f7a69c31e071",
+        "sha256_in_prefix": "823c2ddfd8e275ba31ba2469ce37b419da9aa0d9b799a3e9d7f3f7a69c31e071",
+        "size_in_bytes": 19049
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_windows.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "487ad9a3881ec4e3d528f3a1e0806a138a166b8ac08d3e9338a915ee27300b36",
+        "sha256_in_prefix": "487ad9a3881ec4e3d528f3a1e0806a138a166b8ac08d3e9338a915ee27300b36",
+        "size_in_bytes": 1724
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_windows_renderer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "29e40a735d5407aaf29b1f8b39ff0c7d913437e69c788ddedff5e02f2fae7830",
+        "sha256_in_prefix": "29e40a735d5407aaf29b1f8b39ff0c7d913437e69c788ddedff5e02f2fae7830",
+        "size_in_bytes": 2004
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/_wrap.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a84a330d3a1ec2211620201fba4e1b13fa6fd7f04031c4a1931396fb77a090fd",
+        "sha256_in_prefix": "a84a330d3a1ec2211620201fba4e1b13fa6fd7f04031c4a1931396fb77a090fd",
+        "size_in_bytes": 2362
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/abc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5776c9d6640a070406d6338ad095e41f9a1df9d4e1cb0bcfadd974aef458523b",
+        "sha256_in_prefix": "5776c9d6640a070406d6338ad095e41f9a1df9d4e1cb0bcfadd974aef458523b",
+        "size_in_bytes": 1253
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/align.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "51f82d43284fe7bc030421aaa48d16d13793106c2a12b4c5b10faea2b1048495",
+        "sha256_in_prefix": "51f82d43284fe7bc030421aaa48d16d13793106c2a12b4c5b10faea2b1048495",
+        "size_in_bytes": 7899
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/ansi.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7bda08536ebf7a523c3fb36cf2fd2c333bb9e669a2ede27708d9f3553bc0fd47",
+        "sha256_in_prefix": "7bda08536ebf7a523c3fb36cf2fd2c333bb9e669a2ede27708d9f3553bc0fd47",
+        "size_in_bytes": 5600
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/bar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "42178748d9b487b3e213407b0a2620a423cfeb6fd4a762c828efade6aafc2150",
+        "sha256_in_prefix": "42178748d9b487b3e213407b0a2620a423cfeb6fd4a762c828efade6aafc2150",
+        "size_in_bytes": 2891
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/box.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "088a5d391f930fa6a1281db939ef2a2320c0b4dd507a38fcd49cee11146754ee",
+        "sha256_in_prefix": "088a5d391f930fa6a1281db939ef2a2320c0b4dd507a38fcd49cee11146754ee",
+        "size_in_bytes": 8443
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/cells.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2a79397cc4e1d10526669791b90bcfb28fd646ea1599de454ac9860fbb7366da",
+        "sha256_in_prefix": "2a79397cc4e1d10526669791b90bcfb28fd646ea1599de454ac9860fbb7366da",
+        "size_in_bytes": 4140
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/color.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2cd6caf5d733a200a80670208be1aadad0ef6d843e63b9ff4d0c31fc11c134e1",
+        "sha256_in_prefix": "2cd6caf5d733a200a80670208be1aadad0ef6d843e63b9ff4d0c31fc11c134e1",
+        "size_in_bytes": 15380
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/color_triplet.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2874988ea2025505cb79f44a73c8aaec9cae119dff1ea9563f1f76118d5085e5",
+        "sha256_in_prefix": "2874988ea2025505cb79f44a73c8aaec9cae119dff1ea9563f1f76118d5085e5",
+        "size_in_bytes": 1374
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/columns.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3b0b7f76c909be96648c741fe4cf532bf67228a4436cc01175d3ac0f535d9ed2",
+        "sha256_in_prefix": "3b0b7f76c909be96648c741fe4cf532bf67228a4436cc01175d3ac0f535d9ed2",
+        "size_in_bytes": 6078
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/console.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3e158ca83494529c124b9b5a5f7b06fbba8439ecefff60761612d64cc7e6eb5a",
+        "sha256_in_prefix": "3e158ca83494529c124b9b5a5f7b06fbba8439ecefff60761612d64cc7e6eb5a",
+        "size_in_bytes": 82878
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/constrain.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d560ee7a9a94e5570d83e94df75733afa29304a7142ef6bf3cf5d990ef7d309f",
+        "sha256_in_prefix": "d560ee7a9a94e5570d83e94df75733afa29304a7142ef6bf3cf5d990ef7d309f",
+        "size_in_bytes": 1612
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/containers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ed5981a42387266e0fea407e50ecfda6d202caa73bcefdc96bc52a06697c0118",
+        "sha256_in_prefix": "ed5981a42387266e0fea407e50ecfda6d202caa73bcefdc96bc52a06697c0118",
+        "size_in_bytes": 6378
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/control.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "66f3549bee87a78381a5e1221eef587fdd408e60b31529930c5bd67d84533b90",
+        "sha256_in_prefix": "66f3549bee87a78381a5e1221eef587fdd408e60b31529930c5bd67d84533b90",
+        "size_in_bytes": 8077
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/default_styles.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "088ffcb3dc05c379706f54bb0337731adf07c6407fa38420948d39c6d7959509",
+        "sha256_in_prefix": "088ffcb3dc05c379706f54bb0337731adf07c6407fa38420948d39c6d7959509",
+        "size_in_bytes": 5333
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/diagnose.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "330442e961f455fcf8ad70bd36c2f2ca34b7159fe9c6280e7fef9afcae06d6f2",
+        "sha256_in_prefix": "330442e961f455fcf8ad70bd36c2f2ca34b7159fe9c6280e7fef9afcae06d6f2",
+        "size_in_bytes": 1160
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/emoji.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e37ba37612b4da7a2fd47062dc5c09ba17d2a10ef64e277fca1450a5052d3be9",
+        "sha256_in_prefix": "e37ba37612b4da7a2fd47062dc5c09ba17d2a10ef64e277fca1450a5052d3be9",
+        "size_in_bytes": 3151
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/errors.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1715d800d535791184843deefbf120125798e81eca7e844b50f2eb92d0041a07",
+        "sha256_in_prefix": "1715d800d535791184843deefbf120125798e81eca7e844b50f2eb92d0041a07",
+        "size_in_bytes": 1618
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/file_proxy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "86db677ac10d52e0e7800f50cb4a2380061a22cbd8451f359c670b358e5876f5",
+        "sha256_in_prefix": "86db677ac10d52e0e7800f50cb4a2380061a22cbd8451f359c670b358e5876f5",
+        "size_in_bytes": 2334
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/filesize.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ccc819296e9628e819932aed1c6885d6d96a1840966d6e26300b9635f515c789",
+        "sha256_in_prefix": "ccc819296e9628e819932aed1c6885d6d96a1840966d6e26300b9635f515c789",
+        "size_in_bytes": 2563
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/highlighter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8f4a1df1b3497fcadde029a637a6a7f10e7183e3de828dcc3c6e35056ef8f5dd",
+        "sha256_in_prefix": "8f4a1df1b3497fcadde029a637a6a7f10e7183e3de828dcc3c6e35056ef8f5dd",
+        "size_in_bytes": 7973
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/json.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cd1b5010f93f3a1538aa6e7d94e8db0bdc4b86169cf67876a0dd008411ddccca",
+        "sha256_in_prefix": "cd1b5010f93f3a1538aa6e7d94e8db0bdc4b86169cf67876a0dd008411ddccca",
+        "size_in_bytes": 4636
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/jupyter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "75557b2afc6feeda1ae7b93814b3b4b2a8a83400cae8ac26deda9c0fa40e7d8c",
+        "sha256_in_prefix": "75557b2afc6feeda1ae7b93814b3b4b2a8a83400cae8ac26deda9c0fa40e7d8c",
+        "size_in_bytes": 3982
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/layout.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ac9d8b511e9eeee57c25129c3767bdadd23ea17baac3c02513b78832be5a2b1d",
+        "sha256_in_prefix": "ac9d8b511e9eeee57c25129c3767bdadd23ea17baac3c02513b78832be5a2b1d",
+        "size_in_bytes": 14602
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/live.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "20fe7bd7c0fe39db023f21bc0bb6e0cc45397ea736fa4df7dc85b158c9e9d5d4",
+        "sha256_in_prefix": "20fe7bd7c0fe39db023f21bc0bb6e0cc45397ea736fa4df7dc85b158c9e9d5d4",
+        "size_in_bytes": 11344
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/live_render.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a09f16ee35074726f35c08289808726c3532cc44d7d03af70823fbcd4d4a880c",
+        "sha256_in_prefix": "a09f16ee35074726f35c08289808726c3532cc44d7d03af70823fbcd4d4a880c",
+        "size_in_bytes": 3339
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/logging.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2e512974c166ae915a145586a497ed093f2562ba41e5020835187c0bc58fc0e3",
+        "sha256_in_prefix": "2e512974c166ae915a145586a497ed093f2562ba41e5020835187c0bc58fc0e3",
+        "size_in_bytes": 10192
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/markup.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b05131e41ac33df2998fd2d5f69a26a0ab4c195dc2a0fd84773098bbf0917825",
+        "sha256_in_prefix": "b05131e41ac33df2998fd2d5f69a26a0ab4c195dc2a0fd84773098bbf0917825",
+        "size_in_bytes": 6090
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/measure.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d6f10b9b2a948754f84a5a57c3b2f13b9b3bd1c879da39358d80615483f72170",
+        "sha256_in_prefix": "d6f10b9b2a948754f84a5a57c3b2f13b9b3bd1c879da39358d80615483f72170",
+        "size_in_bytes": 4944
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/padding.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "963d719c6885b3c8108a60d59920d6b2b41531db40523b786844a8417585d4d1",
+        "sha256_in_prefix": "963d719c6885b3c8108a60d59920d6b2b41531db40523b786844a8417585d4d1",
+        "size_in_bytes": 4298
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/pager.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "03a42fe0090f90b59c967f877ad032a19d7f0f8588d5a49e3dc85974d27dff04",
+        "sha256_in_prefix": "03a42fe0090f90b59c967f877ad032a19d7f0f8588d5a49e3dc85974d27dff04",
+        "size_in_bytes": 1402
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/palette.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cbeb7c3aa928d2b32b9a2774be217a29fe7083d37a726658a4cc2d5907297262",
+        "sha256_in_prefix": "cbeb7c3aa928d2b32b9a2774be217a29fe7083d37a726658a4cc2d5907297262",
+        "size_in_bytes": 3637
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/panel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3d8747ffe06c56755718b0bd80656f0cc7406cea7671ebb19d0e4ca1ed511a04",
+        "sha256_in_prefix": "3d8747ffe06c56755718b0bd80656f0cc7406cea7671ebb19d0e4ca1ed511a04",
+        "size_in_bytes": 7874
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/pretty.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4a432b467ebf833db87b359dcbd54fe9aa746755704e1d010ee2bb71ab4b0e44",
+        "sha256_in_prefix": "4a432b467ebf833db87b359dcbd54fe9aa746755704e1d010ee2bb71ab4b0e44",
+        "size_in_bytes": 27627
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/progress.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b799044ca61ac3f6e56881865a77a4e3a9009b427d64c8116dfff0d0bdabba87",
+        "sha256_in_prefix": "b799044ca61ac3f6e56881865a77a4e3a9009b427d64c8116dfff0d0bdabba87",
+        "size_in_bytes": 53925
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/progress_bar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c8607d5e531d678aa19ca804d8f82d4ca1443024c7795571f9fcc80151de173a",
+        "sha256_in_prefix": "c8607d5e531d678aa19ca804d8f82d4ca1443024c7795571f9fcc80151de173a",
+        "size_in_bytes": 6774
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/prompt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3c2e6e16af550e48ea322049c2a4d45ba6878592e1b5cb96bdccc7df4140750c",
+        "sha256_in_prefix": "3c2e6e16af550e48ea322049c2a4d45ba6878592e1b5cb96bdccc7df4140750c",
+        "size_in_bytes": 12214
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/protocol.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "af94e12b51885ed1a475a3d66dd7aee18ef1d21a96f0148fd490a31e9f2cec1a",
+        "sha256_in_prefix": "af94e12b51885ed1a475a3d66dd7aee18ef1d21a96f0148fd490a31e9f2cec1a",
+        "size_in_bytes": 1288
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/region.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7734b2f9c42d9e17f496dd9fc0f73c549fed36da7b124f25eb69afdaef016506",
+        "sha256_in_prefix": "7734b2f9c42d9e17f496dd9fc0f73c549fed36da7b124f25eb69afdaef016506",
+        "size_in_bytes": 474
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/repr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "31ca9ae6d01fc4514db333cc52515e5f7df0bd019319dccfd4abb48a4d30faf8",
+        "sha256_in_prefix": "31ca9ae6d01fc4514db333cc52515e5f7df0bd019319dccfd4abb48a4d30faf8",
+        "size_in_bytes": 4042
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/rule.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "024cc5289f2d19deb6b63c2df5862651dcb9b4c9929b194a8347558dd6dc3256",
+        "sha256_in_prefix": "024cc5289f2d19deb6b63c2df5862651dcb9b4c9929b194a8347558dd6dc3256",
+        "size_in_bytes": 3855
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/scope.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "745657f798b23c48a055a1157fe96f130886d6e0cb6d0f6280db4967316a8001",
+        "sha256_in_prefix": "745657f798b23c48a055a1157fe96f130886d6e0cb6d0f6280db4967316a8001",
+        "size_in_bytes": 2913
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/screen.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "248885ed31ed9de9a67e088728d2d2a00b45fde1f2f7c59ab3b1749075bc059c",
+        "sha256_in_prefix": "248885ed31ed9de9a67e088728d2d2a00b45fde1f2f7c59ab3b1749075bc059c",
+        "size_in_bytes": 1771
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/segment.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "efe94e0b8a0366205a5f9c2f7766672c2f402f6a1781e7c4a6d6395424b982b7",
+        "sha256_in_prefix": "efe94e0b8a0366205a5f9c2f7766672c2f402f6a1781e7c4a6d6395424b982b7",
+        "size_in_bytes": 20923
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/spinner.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b27e62c8661fd0856a6bf143993c3c9b0f3283dba7153a989811f60ce2636b8d",
+        "sha256_in_prefix": "b27e62c8661fd0856a6bf143993c3c9b0f3283dba7153a989811f60ce2636b8d",
+        "size_in_bytes": 4306
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/status.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "01a2c348cad0198da324eca5cc7234728825d8b90a1511ab4e7cf6426159b76a",
+        "sha256_in_prefix": "01a2c348cad0198da324eca5cc7234728825d8b90a1511ab4e7cf6426159b76a",
+        "size_in_bytes": 4524
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/style.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d8847a95ce35d22c1e30a9d34f18b658ab893df88acdea10fdab755578ea2e6e",
+        "sha256_in_prefix": "d8847a95ce35d22c1e30a9d34f18b658ab893df88acdea10fdab755578ea2e6e",
+        "size_in_bytes": 21364
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/styled.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8d129f7b0775eff7de93a2716c246a6ac77eb1e146ebdba1f21c5cb797d7de6c",
+        "sha256_in_prefix": "8d129f7b0775eff7de93a2716c246a6ac77eb1e146ebdba1f21c5cb797d7de6c",
+        "size_in_bytes": 1637
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/syntax.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "681e24691502cdd99e6812fd941d78edab8be17ad272b409497f4055b45e97a4",
+        "sha256_in_prefix": "681e24691502cdd99e6812fd941d78edab8be17ad272b409497f4055b45e97a4",
+        "size_in_bytes": 25869
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/table.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f030cf1484faec3ca562921ad1033570d3c3bfc1a5fcc683de0fd18bf7e6c6f3",
+        "sha256_in_prefix": "f030cf1484faec3ca562921ad1033570d3c3bfc1a5fcc683de0fd18bf7e6c6f3",
+        "size_in_bytes": 29818
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/terminal_theme.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4fdd87dc87b1f2fc9c17eacadf02c88ae8ee5d50d6362d463d1d31b168a0584b",
+        "sha256_in_prefix": "4fdd87dc87b1f2fc9c17eacadf02c88ae8ee5d50d6362d463d1d31b168a0584b",
+        "size_in_bytes": 2945
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/text.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1a5b8246cfa1546bb8de4acf674dce4470516579f19cab0ed852bfc7c6053a7a",
+        "sha256_in_prefix": "1a5b8246cfa1546bb8de4acf674dce4470516579f19cab0ed852bfc7c6053a7a",
+        "size_in_bytes": 41890
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/theme.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4d47ab52480e404b2069aa28ca2cc630c8b3e9843dbf7aa51e48930db594f6ca",
+        "sha256_in_prefix": "4d47ab52480e404b2069aa28ca2cc630c8b3e9843dbf7aa51e48930db594f6ca",
+        "size_in_bytes": 4749
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/themes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8fda65f79aac63474be295f09035e7e49f982d0a702a165f8126cc6ca838a19f",
+        "sha256_in_prefix": "8fda65f79aac63474be295f09035e7e49f982d0a702a165f8126cc6ca838a19f",
+        "size_in_bytes": 242
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/traceback.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "80cfef77aca9175e9647887f5d900607e4ed58a9df1422a4ae5e505b6df62add",
+        "sha256_in_prefix": "80cfef77aca9175e9647887f5d900607e4ed58a9df1422a4ae5e505b6df62add",
+        "size_in_bytes": 22401
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/__pycache__/tree.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fb4834e03c364f716d54033a53a3665ff140834771ff47b055988c78ac5ca346",
+        "sha256_in_prefix": "fb4834e03c364f716d54033a53a3665ff140834771ff47b055988c78ac5ca346",
+        "size_in_bytes": 7481
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_cell_widths.py",
+        "path_type": "hardlink",
+        "sha256": "7db99ec9eb447478f313f571da5d6e2bbb673ce84cb365f59497cedefb0a0e90",
+        "sha256_in_prefix": "7db99ec9eb447478f313f571da5d6e2bbb673ce84cb365f59497cedefb0a0e90",
+        "size_in_bytes": 10209
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_emoji_codes.py",
+        "path_type": "hardlink",
+        "sha256": "86ed552fd9db55da6926b5688a356c85195c4517bfbf7763bb7326776b0a65d6",
+        "sha256_in_prefix": "86ed552fd9db55da6926b5688a356c85195c4517bfbf7763bb7326776b0a65d6",
+        "size_in_bytes": 140235
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_emoji_replace.py",
+        "path_type": "hardlink",
+        "sha256": "9fe91c7adb04531d99526850adf78c35cfad79e1a1a6e490e45f153c1b32bc3a",
+        "sha256_in_prefix": "9fe91c7adb04531d99526850adf78c35cfad79e1a1a6e490e45f153c1b32bc3a",
+        "size_in_bytes": 1064
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_export_format.py",
+        "path_type": "hardlink",
+        "sha256": "448d3ca52ae6e6d052ccf32f9db4ea6c3f5621a95a3a837977833545398bab56",
+        "sha256_in_prefix": "448d3ca52ae6e6d052ccf32f9db4ea6c3f5621a95a3a837977833545398bab56",
+        "size_in_bytes": 2128
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_extension.py",
+        "path_type": "hardlink",
+        "sha256": "5ede3b41a7022b062bbb38c38be80e06aef6e0945e0e3f429bdc548b97ebfb7e",
+        "sha256_in_prefix": "5ede3b41a7022b062bbb38c38be80e06aef6e0945e0e3f429bdc548b97ebfb7e",
+        "size_in_bytes": 265
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_fileno.py",
+        "path_type": "hardlink",
+        "sha256": "1d66713f90b66a331b1ebcaf01066c79f9557d0a06cec28e1f3286b0b0fcca74",
+        "sha256_in_prefix": "1d66713f90b66a331b1ebcaf01066c79f9557d0a06cec28e1f3286b0b0fcca74",
+        "size_in_bytes": 799
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_inspect.py",
+        "path_type": "hardlink",
+        "sha256": "40cd399441671684da16aa676f1fb304423a93ca082ab0f772f8c43903612a28",
+        "sha256_in_prefix": "40cd399441671684da16aa676f1fb304423a93ca082ab0f772f8c43903612a28",
+        "size_in_bytes": 9655
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_log_render.py",
+        "path_type": "hardlink",
+        "sha256": "d41c88d0f035669c5963708624e2b9e218e5ab85fe073fdba088c8a8277c2a7b",
+        "sha256_in_prefix": "d41c88d0f035669c5963708624e2b9e218e5ab85fe073fdba088c8a8277c2a7b",
+        "size_in_bytes": 3225
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_loop.py",
+        "path_type": "hardlink",
+        "sha256": "855ffa08b7683e6d2f6b6d96a70e332aa334458b33dd36715e3d0fa12fbd7834",
+        "sha256_in_prefix": "855ffa08b7683e6d2f6b6d96a70e332aa334458b33dd36715e3d0fa12fbd7834",
+        "size_in_bytes": 1236
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_null_file.py",
+        "path_type": "hardlink",
+        "sha256": "00318aa75cadfa4ef414c295ead9ea0aa79c07ead2273a7e590b03ecb3cbfa48",
+        "sha256_in_prefix": "00318aa75cadfa4ef414c295ead9ea0aa79c07ead2273a7e590b03ecb3cbfa48",
+        "size_in_bytes": 1394
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_palettes.py",
+        "path_type": "hardlink",
+        "sha256": "71d7afd4940a67426f960b95f62a478339d3767be52335050c16f422dd8fce32",
+        "sha256_in_prefix": "71d7afd4940a67426f960b95f62a478339d3767be52335050c16f422dd8fce32",
+        "size_in_bytes": 7063
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_pick.py",
+        "path_type": "hardlink",
+        "sha256": "7af0edf10378945e428b0ad421794e2429ed8ad0423ac23764b3c42005512c95",
+        "sha256_in_prefix": "7af0edf10378945e428b0ad421794e2429ed8ad0423ac23764b3c42005512c95",
+        "size_in_bytes": 423
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_ratio.py",
+        "path_type": "hardlink",
+        "sha256": "66de7c6a9b3323a84001c5cfa607562a9bb7737d5405679b39e47899bca9b6f5",
+        "sha256_in_prefix": "66de7c6a9b3323a84001c5cfa607562a9bb7737d5405679b39e47899bca9b6f5",
+        "size_in_bytes": 5471
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_spinners.py",
+        "path_type": "hardlink",
+        "sha256": "536af5fe0ff5cd28ec8e251d00449cda200c7378b8ae2fd2f0f60fea4439cf52",
+        "sha256_in_prefix": "536af5fe0ff5cd28ec8e251d00449cda200c7378b8ae2fd2f0f60fea4439cf52",
+        "size_in_bytes": 19919
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_stack.py",
+        "path_type": "hardlink",
+        "sha256": "f82f0e2bbaf19f7b0851d570c59041a5e1e12335f4788f9533731e9987da5e6d",
+        "sha256_in_prefix": "f82f0e2bbaf19f7b0851d570c59041a5e1e12335f4788f9533731e9987da5e6d",
+        "size_in_bytes": 351
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_timer.py",
+        "path_type": "hardlink",
+        "sha256": "cde9716d3ea83c566736bc163e973592d51e013f957387ee15c4592d018bb4c2",
+        "sha256_in_prefix": "cde9716d3ea83c566736bc163e973592d51e013f957387ee15c4592d018bb4c2",
+        "size_in_bytes": 417
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_win32_console.py",
+        "path_type": "hardlink",
+        "sha256": "05268344833004b2139ff9b499344b3ea304e6afaab8675232e60ca587982707",
+        "sha256_in_prefix": "05268344833004b2139ff9b499344b3ea304e6afaab8675232e60ca587982707",
+        "size_in_bytes": 22755
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_windows.py",
+        "path_type": "hardlink",
+        "sha256": "681c1a0ff4b9e926e0a2922f6b2566a64d18dbcbb06360b905a6f5c25dc1a7e2",
+        "sha256_in_prefix": "681c1a0ff4b9e926e0a2922f6b2566a64d18dbcbb06360b905a6f5c25dc1a7e2",
+        "size_in_bytes": 1925
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_windows_renderer.py",
+        "path_type": "hardlink",
+        "sha256": "b7be192f7c6e0c23f79e64e9f691f52f92e223671a909b9045095e1c225eae59",
+        "sha256_in_prefix": "b7be192f7c6e0c23f79e64e9f691f52f92e223671a909b9045095e1c225eae59",
+        "size_in_bytes": 2783
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/_wrap.py",
+        "path_type": "hardlink",
+        "sha256": "1654aca26e445f42d5900dca5b2df8c879c27cbb6a5fe6487a95ca87eef4ae97",
+        "sha256_in_prefix": "1654aca26e445f42d5900dca5b2df8c879c27cbb6a5fe6487a95ca87eef4ae97",
+        "size_in_bytes": 3404
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/abc.py",
+        "path_type": "hardlink",
+        "sha256": "38df84f99a924a1799f3c56b297d8cdcf5e915b18451464f31afc07f497ee1fd",
+        "sha256_in_prefix": "38df84f99a924a1799f3c56b297d8cdcf5e915b18451464f31afc07f497ee1fd",
+        "size_in_bytes": 890
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/align.py",
+        "path_type": "hardlink",
+        "sha256": "461fb769d9c368dd40a34ec48d1d8f86013ad8f18b3e03bc48cc09064bb5bab4",
+        "sha256_in_prefix": "461fb769d9c368dd40a34ec48d1d8f86013ad8f18b3e03bc48cc09064bb5bab4",
+        "size_in_bytes": 10469
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/ansi.py",
+        "path_type": "hardlink",
+        "sha256": "02fb352c76d275cc8ebc339da442d952850b7018987b063be9e341a7ab85061b",
+        "sha256_in_prefix": "02fb352c76d275cc8ebc339da442d952850b7018987b063be9e341a7ab85061b",
+        "size_in_bytes": 6921
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/bar.py",
+        "path_type": "hardlink",
+        "sha256": "95d6d51cecca24e9df95536ebf5c52ee0e9d2d7d84df03275e474f6e9cc94dcb",
+        "sha256_in_prefix": "95d6d51cecca24e9df95536ebf5c52ee0e9d2d7d84df03275e474f6e9cc94dcb",
+        "size_in_bytes": 3263
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/box.py",
+        "path_type": "hardlink",
+        "sha256": "9ebe5f608520841fe250212aeb2d19dcb9424fc8053c3af337dbb6927eed265e",
+        "sha256_in_prefix": "9ebe5f608520841fe250212aeb2d19dcb9424fc8053c3af337dbb6927eed265e",
+        "size_in_bytes": 10831
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/cells.py",
+        "path_type": "hardlink",
+        "sha256": "2ab4248f9f8b821082a492d23502320198e775ce1b9c4a8e1268b962e67d5026",
+        "sha256_in_prefix": "2ab4248f9f8b821082a492d23502320198e775ce1b9c4a8e1268b962e67d5026",
+        "size_in_bytes": 5130
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/color.py",
+        "path_type": "hardlink",
+        "sha256": "dc74942d50e3eea4245d47455afefc24e8926737f2e72d6791c6219dadbde95d",
+        "sha256_in_prefix": "dc74942d50e3eea4245d47455afefc24e8926737f2e72d6791c6219dadbde95d",
+        "size_in_bytes": 18211
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/color_triplet.py",
+        "path_type": "hardlink",
+        "sha256": "de585091d25bbd63e82c33be0276089805a626f579765818342559f7b39168de",
+        "sha256_in_prefix": "de585091d25bbd63e82c33be0276089805a626f579765818342559f7b39168de",
+        "size_in_bytes": 1054
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/columns.py",
+        "path_type": "hardlink",
+        "sha256": "1d45f429c326f5db0a362d757d36e233f876883b65f3248269573195a944ceaf",
+        "sha256_in_prefix": "1d45f429c326f5db0a362d757d36e233f876883b65f3248269573195a944ceaf",
+        "size_in_bytes": 7131
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/console.py",
+        "path_type": "hardlink",
+        "sha256": "9ca8eb131ffbc72f0a1a60d54fe060348234479866d5c7b18401c3c1dc0d56a8",
+        "sha256_in_prefix": "9ca8eb131ffbc72f0a1a60d54fe060348234479866d5c7b18401c3c1dc0d56a8",
+        "size_in_bytes": 100156
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/constrain.py",
+        "path_type": "hardlink",
+        "sha256": "d5520fb82f0082d296adc9dc42b8c1758a80dc9556cacbba8d9a35aeb87b73b4",
+        "sha256_in_prefix": "d5520fb82f0082d296adc9dc42b8c1758a80dc9556cacbba8d9a35aeb87b73b4",
+        "size_in_bytes": 1288
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/containers.py",
+        "path_type": "hardlink",
+        "sha256": "73fe7a4f171e74662a0dea4704c4ee65d5088a38ad010827a31f9075ed19d6aa",
+        "sha256_in_prefix": "73fe7a4f171e74662a0dea4704c4ee65d5088a38ad010827a31f9075ed19d6aa",
+        "size_in_bytes": 5502
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/control.py",
+        "path_type": "hardlink",
+        "sha256": "0d29074d440ba2b7d211100a13fa1300450579f667669e1b41be2af2b1db2b0b",
+        "sha256_in_prefix": "0d29074d440ba2b7d211100a13fa1300450579f667669e1b41be2af2b1db2b0b",
+        "size_in_bytes": 6630
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/default_styles.py",
+        "path_type": "hardlink",
+        "sha256": "759c606920fd554cbb49741284edf768b622016b290abdac0906455ff24ad63e",
+        "sha256_in_prefix": "759c606920fd554cbb49741284edf768b622016b290abdac0906455ff24ad63e",
+        "size_in_bytes": 8159
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/diagnose.py",
+        "path_type": "hardlink",
+        "sha256": "6a7eaea2ec2128f025bd0858a4d3691aaf44272b1f3083afbc26cede84a8476e",
+        "sha256_in_prefix": "6a7eaea2ec2128f025bd0858a4d3691aaf44272b1f3083afbc26cede84a8476e",
+        "size_in_bytes": 972
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/emoji.py",
+        "path_type": "hardlink",
+        "sha256": "a264c5f5ab1a027b0ce322d8f78791ffd7604514a6d651d4b335f6d03d726024",
+        "sha256_in_prefix": "a264c5f5ab1a027b0ce322d8f78791ffd7604514a6d651d4b335f6d03d726024",
+        "size_in_bytes": 2501
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/errors.py",
+        "path_type": "hardlink",
+        "sha256": "e693f729ce5de1027f734285b31adfca18e23d57bb275ccea9215b140cdc57e6",
+        "sha256_in_prefix": "e693f729ce5de1027f734285b31adfca18e23d57bb275ccea9215b140cdc57e6",
+        "size_in_bytes": 642
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/file_proxy.py",
+        "path_type": "hardlink",
+        "sha256": "4e5f531cc0d9f8f9395a6f2c23580683f5390e1bac9b10fe159d1f51b714d16d",
+        "sha256_in_prefix": "4e5f531cc0d9f8f9395a6f2c23580683f5390e1bac9b10fe159d1f51b714d16d",
+        "size_in_bytes": 1683
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/filesize.py",
+        "path_type": "hardlink",
+        "sha256": "fe2cfd948a5182f5bb30d49e0999cb83e1f0cdb3f81844e0e78dd6a83f1216cd",
+        "sha256_in_prefix": "fe2cfd948a5182f5bb30d49e0999cb83e1f0cdb3f81844e0e78dd6a83f1216cd",
+        "size_in_bytes": 2484
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/highlighter.py",
+        "path_type": "hardlink",
+        "sha256": "1bfb27fbc0ca8ccd6c1232c6fe8738a2f9169a25295af8fc6d78b4c9e7762e76",
+        "sha256_in_prefix": "1bfb27fbc0ca8ccd6c1232c6fe8738a2f9169a25295af8fc6d78b4c9e7762e76",
+        "size_in_bytes": 9586
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/json.py",
+        "path_type": "hardlink",
+        "sha256": "bd512829d6b0a094630056b23f05e43013cbcbb4524ecf9fe38c124034769c9d",
+        "sha256_in_prefix": "bd512829d6b0a094630056b23f05e43013cbcbb4524ecf9fe38c124034769c9d",
+        "size_in_bytes": 5031
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/jupyter.py",
+        "path_type": "hardlink",
+        "sha256": "432a0aa04ffc21d09baed8921e9f53b1348dc931d8d053b9c2113b8ce4ddf541",
+        "sha256_in_prefix": "432a0aa04ffc21d09baed8921e9f53b1348dc931d8d053b9c2113b8ce4ddf541",
+        "size_in_bytes": 3252
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/layout.py",
+        "path_type": "hardlink",
+        "sha256": "6a3912140b4456ff44153705b3ec38b997dfb7b9c45e13732fb655760ad3e6b2",
+        "sha256_in_prefix": "6a3912140b4456ff44153705b3ec38b997dfb7b9c45e13732fb655760ad3e6b2",
+        "size_in_bytes": 14004
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/live.py",
+        "path_type": "hardlink",
+        "sha256": "0e1cc03c49e34f142eabdff4636c61d8c53041c3ff6863e47a72df2844ec9703",
+        "sha256_in_prefix": "0e1cc03c49e34f142eabdff4636c61d8c53041c3ff6863e47a72df2844ec9703",
+        "size_in_bytes": 14270
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/live_render.py",
+        "path_type": "hardlink",
+        "sha256": "cc9b41e3bd631b3881b44c31739e31d76c0442d1f806e42bd5203cbfd914f36c",
+        "sha256_in_prefix": "cc9b41e3bd631b3881b44c31739e31d76c0442d1f806e42bd5203cbfd914f36c",
+        "size_in_bytes": 3666
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/logging.py",
+        "path_type": "hardlink",
+        "sha256": "660a4a30c058fc1b8c008fc1633a3e52d5da93ab79a07f552bc9bd4362e6d1fe",
+        "sha256_in_prefix": "660a4a30c058fc1b8c008fc1633a3e52d5da93ab79a07f552bc9bd4362e6d1fe",
+        "size_in_bytes": 12458
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/markup.py",
+        "path_type": "hardlink",
+        "sha256": "ddeb8628fe6ce353424306928d39c9c6eb398993078f1a483345ba7c2c6b6b7f",
+        "sha256_in_prefix": "ddeb8628fe6ce353424306928d39c9c6eb398993078f1a483345ba7c2c6b6b7f",
+        "size_in_bytes": 8451
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/measure.py",
+        "path_type": "hardlink",
+        "sha256": "1e6ac8257f2c5914c76e087c33111acbff37564a8d5bfef4b3c68a3f965c608f",
+        "sha256_in_prefix": "1e6ac8257f2c5914c76e087c33111acbff37564a8d5bfef4b3c68a3f965c608f",
+        "size_in_bytes": 5305
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/padding.py",
+        "path_type": "hardlink",
+        "sha256": "295108ded3b0a3db202b560d4ae1fffccd7f8d45a62d9c11555fca98eb55cf23",
+        "sha256_in_prefix": "295108ded3b0a3db202b560d4ae1fffccd7f8d45a62d9c11555fca98eb55cf23",
+        "size_in_bytes": 4908
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/pager.py",
+        "path_type": "hardlink",
+        "sha256": "48efc44c114a6e0de7fc080ecd79b8d52bf7e98c57032237fd1f8a398dbfb927",
+        "sha256_in_prefix": "48efc44c114a6e0de7fc080ecd79b8d52bf7e98c57032237fd1f8a398dbfb927",
+        "size_in_bytes": 828
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/palette.py",
+        "path_type": "hardlink",
+        "sha256": "9489ef4753830d3d9fdd464c7cbd60aeaedd63fa4374a1f0e1b75480e19a3386",
+        "sha256_in_prefix": "9489ef4753830d3d9fdd464c7cbd60aeaedd63fa4374a1f0e1b75480e19a3386",
+        "size_in_bytes": 3396
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/panel.py",
+        "path_type": "hardlink",
+        "sha256": "7c544772f897bd6864dd5df3c796709ac6ff44bf4a2777ac0feb14d0d604572c",
+        "sha256_in_prefix": "7c544772f897bd6864dd5df3c796709ac6ff44bf4a2777ac0feb14d0d604572c",
+        "size_in_bytes": 11235
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/pretty.py",
+        "path_type": "hardlink",
+        "sha256": "832dd2ef6bb8151836cada28ecdd590d60c8bc1e2e9dbcdde625067609bef1f7",
+        "sha256_in_prefix": "832dd2ef6bb8151836cada28ecdd590d60c8bc1e2e9dbcdde625067609bef1f7",
+        "size_in_bytes": 36391
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/progress.py",
+        "path_type": "hardlink",
+        "sha256": "32d9828d3939cd853f5ed447c511d30041c6ea117d3de17b10c59b10f95e202d",
+        "sha256_in_prefix": "32d9828d3939cd853f5ed447c511d30041c6ea117d3de17b10c59b10f95e202d",
+        "size_in_bytes": 60357
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/progress_bar.py",
+        "path_type": "hardlink",
+        "sha256": "9994cfa4953071f71d8100934f3de4c98f9f73bf5d74bc2dc7a1a18717e8d3ae",
+        "sha256_in_prefix": "9994cfa4953071f71d8100934f3de4c98f9f73bf5d74bc2dc7a1a18717e8d3ae",
+        "size_in_bytes": 8162
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/prompt.py",
+        "path_type": "hardlink",
+        "sha256": "974461414fb45154d5f5ed3cc56d416c88f426ad885f20a15f8942d2514dcede",
+        "sha256_in_prefix": "974461414fb45154d5f5ed3cc56d416c88f426ad885f20a15f8942d2514dcede",
+        "size_in_bytes": 12447
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/protocol.py",
+        "path_type": "hardlink",
+        "sha256": "e611c70c3347724764f22587e7311b8becee215485e616d4da3228e3b47b9531",
+        "sha256_in_prefix": "e611c70c3347724764f22587e7311b8becee215485e616d4da3228e3b47b9531",
+        "size_in_bytes": 1391
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/region.py",
+        "path_type": "hardlink",
+        "sha256": "acd4fdc59ad56536085d90b43589f8d42250c1835b47e29e70f3b14e042f07c6",
+        "sha256_in_prefix": "acd4fdc59ad56536085d90b43589f8d42250c1835b47e29e70f3b14e042f07c6",
+        "size_in_bytes": 166
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/repr.py",
+        "path_type": "hardlink",
+        "sha256": "e4c64966638d802ea4b9df905befe6d68917c0bd9a47abbacbea54714089cf6f",
+        "sha256_in_prefix": "e4c64966638d802ea4b9df905befe6d68917c0bd9a47abbacbea54714089cf6f",
+        "size_in_bytes": 4431
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/rule.py",
+        "path_type": "hardlink",
+        "sha256": "d1f35a4bf68445add43117374f958ca4dfecba6b43c5f6a8af6cb7a1fd5fb419",
+        "sha256_in_prefix": "d1f35a4bf68445add43117374f958ca4dfecba6b43c5f6a8af6cb7a1fd5fb419",
+        "size_in_bytes": 4602
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/scope.py",
+        "path_type": "hardlink",
+        "sha256": "4cc514f2aa35eed872a9008faa30cb62983f514d64e6a55df96c2226f9c955ab",
+        "sha256_in_prefix": "4cc514f2aa35eed872a9008faa30cb62983f514d64e6a55df96c2226f9c955ab",
+        "size_in_bytes": 2843
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/screen.py",
+        "path_type": "hardlink",
+        "sha256": "628791784494871ef882ba9bd264926fd960861cac5a6147621b1b3154235cef",
+        "sha256_in_prefix": "628791784494871ef882ba9bd264926fd960861cac5a6147621b1b3154235cef",
+        "size_in_bytes": 1591
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/segment.py",
+        "path_type": "hardlink",
+        "sha256": "a2d9ca78a18457e591950568b1f2557850dc0f100a1e9bc9fe12f34aee65ba63",
+        "sha256_in_prefix": "a2d9ca78a18457e591950568b1f2557850dc0f100a1e9bc9fe12f34aee65ba63",
+        "size_in_bytes": 24743
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/spinner.py",
+        "path_type": "hardlink",
+        "sha256": "3d3e6a8173c6dd9a6a463ee7dc4650e8d5b9ea6c7795d66a64253b804332664e",
+        "sha256_in_prefix": "3d3e6a8173c6dd9a6a463ee7dc4650e8d5b9ea6c7795d66a64253b804332664e",
+        "size_in_bytes": 4364
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/status.py",
+        "path_type": "hardlink",
+        "sha256": "9243e987761e019068f97fb8c0fa7c813a99c94e3ae8d2f06410383d94d37b0a",
+        "sha256_in_prefix": "9243e987761e019068f97fb8c0fa7c813a99c94e3ae8d2f06410383d94d37b0a",
+        "size_in_bytes": 4424
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/style.py",
+        "path_type": "hardlink",
+        "sha256": "692a1435b5607cfd4f02776e02a81b6e5e00310cbaebcaacd92d45130af73aab",
+        "sha256_in_prefix": "692a1435b5607cfd4f02776e02a81b6e5e00310cbaebcaacd92d45130af73aab",
+        "size_in_bytes": 27067
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/styled.py",
+        "path_type": "hardlink",
+        "sha256": "799367cc6ac8e248bfe78a606373a3d13fb1de5c5d5d3621e3faf20c1db8c015",
+        "sha256_in_prefix": "799367cc6ac8e248bfe78a606373a3d13fb1de5c5d5d3621e3faf20c1db8c015",
+        "size_in_bytes": 1258
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/syntax.py",
+        "path_type": "hardlink",
+        "sha256": "aaa0271146782b9ecfa3cd7fe510719ecb94e0a47349dbc33c084ac3c99aff71",
+        "sha256_in_prefix": "aaa0271146782b9ecfa3cd7fe510719ecb94e0a47349dbc33c084ac3c99aff71",
+        "size_in_bytes": 35763
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/table.py",
+        "path_type": "hardlink",
+        "sha256": "c97614af462c3e91b8eba379d07080c366e96f9654baecdd73e1bae9993ea137",
+        "sha256_in_prefix": "c97614af462c3e91b8eba379d07080c366e96f9654baecdd73e1bae9993ea137",
+        "size_in_bytes": 40103
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/terminal_theme.py",
+        "path_type": "hardlink",
+        "sha256": "d63e7eb9f25f9ef940a3942c8bf0026625c39b0317cea826141c8e6d3f7ec896",
+        "sha256_in_prefix": "d63e7eb9f25f9ef940a3942c8bf0026625c39b0317cea826141c8e6d3f7ec896",
+        "size_in_bytes": 3370
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/text.py",
+        "path_type": "hardlink",
+        "sha256": "00eec93c2cfafa068dd6d8552d73019ed1260cf55816014d1b5a0ceb5fec6a75",
+        "sha256_in_prefix": "00eec93c2cfafa068dd6d8552d73019ed1260cf55816014d1b5a0ceb5fec6a75",
+        "size_in_bytes": 47552
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/theme.py",
+        "path_type": "hardlink",
+        "sha256": "a0dca15e119a82d0e56c3c9eded56eddeb16396934bcd92ec45c3efee9e568ad",
+        "sha256_in_prefix": "a0dca15e119a82d0e56c3c9eded56eddeb16396934bcd92ec45c3efee9e568ad",
+        "size_in_bytes": 3771
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/themes.py",
+        "path_type": "hardlink",
+        "sha256": "d318132e8cdf69b79b62d709b43742e50917e4855411abe2a83509261e185459",
+        "sha256_in_prefix": "d318132e8cdf69b79b62d709b43742e50917e4855411abe2a83509261e185459",
+        "size_in_bytes": 102
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/traceback.py",
+        "path_type": "hardlink",
+        "sha256": "cfc52837b35b4d0296e980c3515c0e87b17cb2765fea0627516b4eacab0b135c",
+        "sha256_in_prefix": "cfc52837b35b4d0296e980c3515c0e87b17cb2765fea0627516b4eacab0b135c",
+        "size_in_bytes": 31797
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/rich/tree.py",
+        "path_type": "hardlink",
+        "sha256": "c969d0eab02f446277a991aa06bc52d925b64ca05336b3f449d63c4313853eec",
+        "sha256_in_prefix": "c969d0eab02f446277a991aa06bc52d925b64ca05336b3f449d63c4313853eec",
+        "size_in_bytes": 9451
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/tomli/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "3e1370fdec8b81d9fb31c27a9eb00df32226ddd5c2ef9bebd6c546555c034a90",
+        "sha256_in_prefix": "3e1370fdec8b81d9fb31c27a9eb00df32226ddd5c2ef9bebd6c546555c034a90",
+        "size_in_bytes": 314
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/tomli/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "340360525b0483c7f211782ca1c82bfe11c1d3a23870bca81ada2d98ad07b14a",
+        "sha256_in_prefix": "340360525b0483c7f211782ca1c82bfe11c1d3a23870bca81ada2d98ad07b14a",
+        "size_in_bytes": 274
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/tomli/__pycache__/_parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fe7622ae6b0f8ec654b93c9fc85d350d38e0ec0ce4757191eb579652b31621a7",
+        "sha256_in_prefix": "fe7622ae6b0f8ec654b93c9fc85d350d38e0ec0ce4757191eb579652b31621a7",
+        "size_in_bytes": 18072
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/tomli/__pycache__/_re.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "99227dd469a61d6fae4a3f5a9bee5922b78abda5c1605426e4bdf1c15a4d44e7",
+        "sha256_in_prefix": "99227dd469a61d6fae4a3f5a9bee5922b78abda5c1605426e4bdf1c15a4d44e7",
+        "size_in_bytes": 2877
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/tomli/__pycache__/_types.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b8d7c0e4514ea3c2c25af54ba6aaae811d92553c2c12b692d4c4f3e075ee368d",
+        "sha256_in_prefix": "b8d7c0e4514ea3c2c25af54ba6aaae811d92553c2c12b692d4c4f3e075ee368d",
+        "size_in_bytes": 274
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/tomli/_parser.py",
+        "path_type": "hardlink",
+        "sha256": "f70f0b1b48c1edfc26659581d2f5576de7a30c7725e00348271076b1c1270e50",
+        "sha256_in_prefix": "f70f0b1b48c1edfc26659581d2f5576de7a30c7725e00348271076b1c1270e50",
+        "size_in_bytes": 25591
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/tomli/_re.py",
+        "path_type": "hardlink",
+        "sha256": "b21e2c0434603bde0a259c0d22b81d73257fa906acb79d18bf3380506a510ca0",
+        "sha256_in_prefix": "b21e2c0434603bde0a259c0d22b81d73257fa906acb79d18bf3380506a510ca0",
+        "size_in_bytes": 3171
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/tomli/_types.py",
+        "path_type": "hardlink",
+        "sha256": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74",
+        "sha256_in_prefix": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74",
+        "size_in_bytes": 254
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/tomli/py.typed",
+        "path_type": "hardlink",
+        "sha256": "f0f8f2675695a10a5156fb7bd66bafbaae6a13e8d315990af862c792175e6e67",
+        "sha256_in_prefix": "f0f8f2675695a10a5156fb7bd66bafbaae6a13e8d315990af862c792175e6e67",
+        "size_in_bytes": 26
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "5880decb35a6ec4557e38837e78336e6fa515db798d65b0f1fa12650951cab8a",
+        "sha256_in_prefix": "5880decb35a6ec4557e38837e78336e6fa515db798d65b0f1fa12650951cab8a",
+        "size_in_bytes": 1264
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0fa1e4c84413d51f48bbdfe0173adfe1b56f1cf068fd168d1604fb45956060e1",
+        "sha256_in_prefix": "0fa1e4c84413d51f48bbdfe0173adfe1b56f1cf068fd168d1604fb45956060e1",
+        "size_in_bytes": 910
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/__pycache__/_api.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "962411357256e9f05af427b8add104da0964af4b4ed6b75397b5e748c1590802",
+        "sha256_in_prefix": "962411357256e9f05af427b8add104da0964af4b4ed6b75397b5e748c1590802",
+        "size_in_bytes": 10651
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/__pycache__/_macos.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "294fa760d13e7728064a9d801c84d39ac8ca161d49b63a157d8b7650ca15ecd4",
+        "sha256_in_prefix": "294fa760d13e7728064a9d801c84d39ac8ca161d49b63a157d8b7650ca15ecd4",
+        "size_in_bytes": 10059
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/__pycache__/_openssl.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6e960679fe5a35ea3e3b48c587a4a2a53242cf993e02b9935f9f2c0ebd01149a",
+        "sha256_in_prefix": "6e960679fe5a35ea3e3b48c587a4a2a53242cf993e02b9935f9f2c0ebd01149a",
+        "size_in_bytes": 1419
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8611efd9ac3054e425728303080080709396f5b5ad8d201225231d24a8b89461",
+        "sha256_in_prefix": "8611efd9ac3054e425728303080080709396f5b5ad8d201225231d24a8b89461",
+        "size_in_bytes": 735
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/__pycache__/_windows.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b2047bd49a0d84030564497ceb42f8f0f2dff0ae6247a2e046091afb37b1ac83",
+        "sha256_in_prefix": "b2047bd49a0d84030564497ceb42f8f0f2dff0ae6247a2e046091afb37b1ac83",
+        "size_in_bytes": 10513
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/_api.py",
+        "path_type": "hardlink",
+        "sha256": "19e5d13539713d9de489fe2436887a258d28138411cd319c817afa97f5ff1a4d",
+        "sha256_in_prefix": "19e5d13539713d9de489fe2436887a258d28138411cd319c817afa97f5ff1a4d",
+        "size_in_bytes": 10555
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/_macos.py",
+        "path_type": "hardlink",
+        "sha256": "9d994b90e9accd413483aaf2470055198e423b33f2b9d72c889b4359aacce4b4",
+        "sha256_in_prefix": "9d994b90e9accd413483aaf2470055198e423b33f2b9d72c889b4359aacce4b4",
+        "size_in_bytes": 20503
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/_openssl.py",
+        "path_type": "hardlink",
+        "sha256": "2cb519ed919a8a8fa2e5da4a2a328249e4ae7e69fa4fca62f650dc167bd2caad",
+        "sha256_in_prefix": "2cb519ed919a8a8fa2e5da4a2a328249e4ae7e69fa4fca62f650dc167bd2caad",
+        "size_in_bytes": 2324
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/_ssl_constants.py",
+        "path_type": "hardlink",
+        "sha256": "3540f87d529d483d36ae2efe75bd2d9ced15a8b3fd687bb3992b5c5bbb40974f",
+        "sha256_in_prefix": "3540f87d529d483d36ae2efe75bd2d9ced15a8b3fd687bb3992b5c5bbb40974f",
+        "size_in_bytes": 1130
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/_windows.py",
+        "path_type": "hardlink",
+        "sha256": "ac01f22980fc33bb7e6d77c6f1580e55add3a5f85585bb78ad94253b8e58b8ff",
+        "sha256_in_prefix": "ac01f22980fc33bb7e6d77c6f1580e55add3a5f85585bb78ad94253b8e58b8ff",
+        "size_in_bytes": 17993
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/truststore/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/typing_extensions.py",
+        "path_type": "hardlink",
+        "sha256": "efc8459741e90d8fb29475150a759d5399d31f150fdbe4bedf011993a09098b9",
+        "sha256_in_prefix": "efc8459741e90d8fb29475150a759d5399d31f150fdbe4bedf011993a09098b9",
+        "size_in_bytes": 134499
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "8972dc6222724a7d0635b58e3990c30298012f52603f8e0467c8b5efad12f0c7",
+        "sha256_in_prefix": "8972dc6222724a7d0635b58e3990c30298012f52603f8e0467c8b5efad12f0c7",
+        "size_in_bytes": 3333
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c770bfeaa6248ee5da7f515540e0dcd4a955e66d233bbbf7f9235a5eece4f516",
+        "sha256_in_prefix": "c770bfeaa6248ee5da7f515540e0dcd4a955e66d233bbbf7f9235a5eece4f516",
+        "size_in_bytes": 2456
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/_collections.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "206197bbe1dd3d3ebe395ddd53df8c0e79fc13f39a7b9016c4893d8e150dfca2",
+        "sha256_in_prefix": "206197bbe1dd3d3ebe395ddd53df8c0e79fc13f39a7b9016c4893d8e150dfca2",
+        "size_in_bytes": 11224
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/_version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fbe153ca60c113b1d45cf31094179aa9e6493f3880cbfa537b8d0f2c0e130fdc",
+        "sha256_in_prefix": "fbe153ca60c113b1d45cf31094179aa9e6493f3880cbfa537b8d0f2c0e130fdc",
+        "size_in_bytes": 163
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/connection.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6087105cda2e464fc47341a9d9d920e39386f090586648b31fd575382ae67b38",
+        "sha256_in_prefix": "6087105cda2e464fc47341a9d9d920e39386f090586648b31fd575382ae67b38",
+        "size_in_bytes": 13692
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/connectionpool.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a31deea223ba9e8b8aa2bbea06ccf7881b29e556c5c11d4611d0c5ae74ae8455",
+        "sha256_in_prefix": "a31deea223ba9e8b8aa2bbea06ccf7881b29e556c5c11d4611d0c5ae74ae8455",
+        "size_in_bytes": 25892
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/exceptions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1c757f3d4c233a067a51a9d7e7d660e98769abf96c8a9b0831b7110b3c3f3f76",
+        "sha256_in_prefix": "1c757f3d4c233a067a51a9d7e7d660e98769abf96c8a9b0831b7110b3c3f3f76",
+        "size_in_bytes": 11595
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/fields.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6174cba24f206268439775680e3baf327e79e790c9e90df9becf4fb52912246f",
+        "sha256_in_prefix": "6174cba24f206268439775680e3baf327e79e790c9e90df9becf4fb52912246f",
+        "size_in_bytes": 8110
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/filepost.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2bcc7c9690495944526c7a9442e2fae179b339040e3ad38758a38b5450e97864",
+        "sha256_in_prefix": "2bcc7c9690495944526c7a9442e2fae179b339040e3ad38758a38b5450e97864",
+        "size_in_bytes": 2711
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/poolmanager.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1ead6ee18fd7798112889a5c837929f4a0bd1bb573e3e7be8363b3cdca891883",
+        "sha256_in_prefix": "1ead6ee18fd7798112889a5c837929f4a0bd1bb573e3e7be8363b3cdca891883",
+        "size_in_bytes": 15077
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/request.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9e386dc6c1d1c41adc2f54bdbf5f7eb1e285aa8cf8d108ea9ef2b1905b7ceea5",
+        "sha256_in_prefix": "9e386dc6c1d1c41adc2f54bdbf5f7eb1e285aa8cf8d108ea9ef2b1905b7ceea5",
+        "size_in_bytes": 6335
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/__pycache__/response.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c4a69cc89ceabbe89de7f2d160da992c71815d4b19d84a39317c50223c5716a9",
+        "sha256_in_prefix": "c4a69cc89ceabbe89de7f2d160da992c71815d4b19d84a39317c50223c5716a9",
+        "size_in_bytes": 22342
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/_collections.py",
+        "path_type": "hardlink",
+        "sha256": "a72012249856ef074ea6a263f50240f05c8645fafc13cb94521a94be1174ef6f",
+        "sha256_in_prefix": "a72012249856ef074ea6a263f50240f05c8645fafc13cb94521a94be1174ef6f",
+        "size_in_bytes": 11372
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/_version.py",
+        "path_type": "hardlink",
+        "sha256": "b7dc0607aa283935d782263ae8ad66e81652d422725c7014f04a160d37ba4a19",
+        "sha256_in_prefix": "b7dc0607aa283935d782263ae8ad66e81652d422725c7014f04a160d37ba4a19",
+        "size_in_bytes": 64
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/connection.py",
+        "path_type": "hardlink",
+        "sha256": "b6d200f74f41adb4d4cf092a11efd3cd9561e0938e8fb83ad58b1e8b69abc068",
+        "sha256_in_prefix": "b6d200f74f41adb4d4cf092a11efd3cd9561e0938e8fb83ad58b1e8b69abc068",
+        "size_in_bytes": 20314
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/connectionpool.py",
+        "path_type": "hardlink",
+        "sha256": "7b67a203035b14d08ac63e1bc0328d2bec3b1c8752cf73a633153f4c8b7e7af4",
+        "sha256_in_prefix": "7b67a203035b14d08ac63e1bc0328d2bec3b1c8752cf73a633153f4c8b7e7af4",
+        "size_in_bytes": 40408
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8f7baacddc46dcdb1a628c4394c9dcb1c22086f80f12c50383b005e5fdacf6e1",
+        "sha256_in_prefix": "8f7baacddc46dcdb1a628c4394c9dcb1c22086f80f12c50383b005e5fdacf6e1",
+        "size_in_bytes": 148
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8918d49e82a6149bcbaad599715369a6240b40c7838a713820eff397e653aafc",
+        "sha256_in_prefix": "8918d49e82a6149bcbaad599715369a6240b40c7838a713820eff397e653aafc",
+        "size_in_bytes": 1368
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f803fbc278a7db2e1de4927e1b5a70fe731c0edf605078d71f500b9c402dcafb",
+        "sha256_in_prefix": "f803fbc278a7db2e1de4927e1b5a70fe731c0edf605078d71f500b9c402dcafb",
+        "size_in_bytes": 8222
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8ce35e72b049982b9e984f01258710b3adcc31a503bd263d9c2718c2b92ef00c",
+        "sha256_in_prefix": "8ce35e72b049982b9e984f01258710b3adcc31a503bd263d9c2718c2b92ef00c",
+        "size_in_bytes": 3564
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "09ed811eac3f87024aea4d3f9ae268418423cf241618ba0c42f3bb02b5151e20",
+        "sha256_in_prefix": "09ed811eac3f87024aea4d3f9ae268418423cf241618ba0c42f3bb02b5151e20",
+        "size_in_bytes": 15825
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0e18a21b221930aa6e7b47e802607c3937c17108ce926ce33e58495ee5bd4beb",
+        "sha256_in_prefix": "0e18a21b221930aa6e7b47e802607c3937c17108ce926ce33e58495ee5bd4beb",
+        "size_in_bytes": 21871
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "00688b933e18d25a4269d48b3ff1f09b241aeeed20dfaba3aa5460dbcb3407e4",
+        "sha256_in_prefix": "00688b933e18d25a4269d48b3ff1f09b241aeeed20dfaba3aa5460dbcb3407e4",
+        "size_in_bytes": 5584
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py",
+        "path_type": "hardlink",
+        "sha256": "6c36f2384856d8228b25c42a00a032ac41cdf9a925b321c52aaeaf17c645b269",
+        "sha256_in_prefix": "6c36f2384856d8228b25c42a00a032ac41cdf9a925b321c52aaeaf17c645b269",
+        "size_in_bytes": 957
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c3814cccfbbe275897b009212f2b831051a790f0b9fd457a76fa739f80064ceb",
+        "sha256_in_prefix": "c3814cccfbbe275897b009212f2b831051a790f0b9fd457a76fa739f80064ceb",
+        "size_in_bytes": 165
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "011398e5d8ebe060be6d0860c8c7f95f093a4bf788ece9f07f23e9fd07b1370b",
+        "sha256_in_prefix": "011398e5d8ebe060be6d0860c8c7f95f093a4bf788ece9f07f23e9fd07b1370b",
+        "size_in_bytes": 10657
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "932e04aecaa639b7d139d3d1d2e93a390e0af1b90ad2ad8928e453975adef295",
+        "sha256_in_prefix": "932e04aecaa639b7d139d3d1d2e93a390e0af1b90ad2ad8928e453975adef295",
+        "size_in_bytes": 9125
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py",
+        "path_type": "hardlink",
+        "sha256": "e1793ae2a2243c1b74f40e6af9120552e0e135cf665e29556a99bb5a7627cd1c",
+        "sha256_in_prefix": "e1793ae2a2243c1b74f40e6af9120552e0e135cf665e29556a99bb5a7627cd1c",
+        "size_in_bytes": 17632
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py",
+        "path_type": "hardlink",
+        "sha256": "076241076fcd44fd36c4ae8309ad4f6bd22ec6b3f0c730f365b8b14246fb53d3",
+        "sha256_in_prefix": "076241076fcd44fd36c4ae8309ad4f6bd22ec6b3f0c730f365b8b14246fb53d3",
+        "size_in_bytes": 13922
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/appengine.py",
+        "path_type": "hardlink",
+        "sha256": "551ebc780544d77ee5c53823043c029dae5488165338a6b4d408fffb905a0b3e",
+        "sha256_in_prefix": "551ebc780544d77ee5c53823043c029dae5488165338a6b4d408fffb905a0b3e",
+        "size_in_bytes": 11036
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py",
+        "path_type": "hardlink",
+        "sha256": "3657e45bb58c756f338aab9da298c7a16dbdf688350535a2d0878889baae1709",
+        "sha256_in_prefix": "3657e45bb58c756f338aab9da298c7a16dbdf688350535a2d0878889baae1709",
+        "size_in_bytes": 4528
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py",
+        "path_type": "hardlink",
+        "sha256": "843261e0c87263fa7ea0a9457187106954110efe86326046b96f728f1c9e7a33",
+        "sha256_in_prefix": "843261e0c87263fa7ea0a9457187106954110efe86326046b96f728f1c9e7a33",
+        "size_in_bytes": 17081
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/securetransport.py",
+        "path_type": "hardlink",
+        "sha256": "15e7f5208514147aa97afcd78833db20690329c858d8554a79578b191d50ab78",
+        "sha256_in_prefix": "15e7f5208514147aa97afcd78833db20690329c858d8554a79578b191d50ab78",
+        "size_in_bytes": 34446
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/contrib/socks.py",
+        "path_type": "hardlink",
+        "sha256": "6918bd7965e8f5911bf795d4c5e7f8676d421659e78db122028f473ac7a832de",
+        "sha256_in_prefix": "6918bd7965e8f5911bf795d4c5e7f8676d421659e78db122028f473ac7a832de",
+        "size_in_bytes": 7097
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/exceptions.py",
+        "path_type": "hardlink",
+        "sha256": "d0c9e7a372874cd7d745f63beb7f0db9f38f9146fa9973a6f8baa3fb8c76c3c0",
+        "sha256_in_prefix": "d0c9e7a372874cd7d745f63beb7f0db9f38f9146fa9973a6f8baa3fb8c76c3c0",
+        "size_in_bytes": 8217
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/fields.py",
+        "path_type": "hardlink",
+        "sha256": "92f2c30a0fc9987d652e3514118fc52d2f14858ee106f0cfb951136d8f2676b3",
+        "sha256_in_prefix": "92f2c30a0fc9987d652e3514118fc52d2f14858ee106f0cfb951136d8f2676b3",
+        "size_in_bytes": 8579
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/filepost.py",
+        "path_type": "hardlink",
+        "sha256": "e5bfeaaa04475652fbb8bb5d018073061f861e653901f255b7fd8dd174b73de6",
+        "sha256_in_prefix": "e5bfeaaa04475652fbb8bb5d018073061f861e653901f255b7fd8dd174b73de6",
+        "size_in_bytes": 2440
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8bbde6843838ff42aec987f428b9356b94706a6c2c2bbd2f6b6d2de8f699062b",
+        "sha256_in_prefix": "8bbde6843838ff42aec987f428b9356b94706a6c2c2bbd2f6b6d2de8f699062b",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/__pycache__/six.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8911dbeddf179add9acb08fd4ea57660c2abd50718be126b34b07765d166cb37",
+        "sha256_in_prefix": "8911dbeddf179add9acb08fd4ea57660c2abd50718be126b34b07765d166cb37",
+        "size_in_bytes": 27532
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/backports/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3eb04a7a464b3697ca6114f229d1daa3ba9d913a885ae8362c5ee19a65a03f37",
+        "sha256_in_prefix": "3eb04a7a464b3697ca6114f229d1daa3ba9d913a885ae8362c5ee19a65a03f37",
+        "size_in_bytes": 159
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6bdad704c00f5c5065dda0e94f399634f877b681002d5680f5dc71b3398b0308",
+        "sha256_in_prefix": "6bdad704c00f5c5065dda0e94f399634f877b681002d5680f5dc71b3398b0308",
+        "size_in_bytes": 1257
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "65dc4bb0f8b25a823ef8c387d9b18077f07246bdb4854e385b7db5c49d4df852",
+        "sha256_in_prefix": "65dc4bb0f8b25a823ef8c387d9b18077f07246bdb4854e385b7db5c49d4df852",
+        "size_in_bytes": 4811
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/backports/makefile.py",
+        "path_type": "hardlink",
+        "sha256": "9dbcedde2d1a80f54fd3b8eaaa08e16988cc9ae022fd6e44d04cb0662bd53bc1",
+        "sha256_in_prefix": "9dbcedde2d1a80f54fd3b8eaaa08e16988cc9ae022fd6e44d04cb0662bd53bc1",
+        "size_in_bytes": 1417
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/backports/weakref_finalize.py",
+        "path_type": "hardlink",
+        "sha256": "b5109a97938084d491c9bd03847a7edfc02d2250ac44ff01c45dcd5feeaba880",
+        "sha256_in_prefix": "b5109a97938084d491c9bd03847a7edfc02d2250ac44ff01c45dcd5feeaba880",
+        "size_in_bytes": 5343
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/packages/six.py",
+        "path_type": "hardlink",
+        "sha256": "6fd2ccd30057bfb13b4ab6c28c09b8c3037e86b1fe88dc6fd7c2e058d30c28fa",
+        "sha256_in_prefix": "6fd2ccd30057bfb13b4ab6c28c09b8c3037e86b1fe88dc6fd7c2e058d30c28fa",
+        "size_in_bytes": 34665
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/poolmanager.py",
+        "path_type": "hardlink",
+        "sha256": "696ca15d1b4d3b82549c249556a29329077c1174ef526d5537da60b366dc38da",
+        "sha256_in_prefix": "696ca15d1b4d3b82549c249556a29329077c1174ef526d5537da60b366dc38da",
+        "size_in_bytes": 19990
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/request.py",
+        "path_type": "hardlink",
+        "sha256": "61358536bed023087b1355bd75d7bd2ccefbbf65564c9e55efc5ee4d3c3b0f50",
+        "sha256_in_prefix": "61358536bed023087b1355bd75d7bd2ccefbbf65564c9e55efc5ee4d3c3b0f50",
+        "size_in_bytes": 6691
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/response.py",
+        "path_type": "hardlink",
+        "sha256": "7e60c9005906ef5b854e7fac5524e1d88c345a6717418aa46d18e286fc018d4f",
+        "sha256_in_prefix": "7e60c9005906ef5b854e7fac5524e1d88c345a6717418aa46d18e286fc018d4f",
+        "size_in_bytes": 30641
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "2449929a6aaa2f26b0f0fe75814226661f06c20f62d7349ef83a2a022b67da77",
+        "sha256_in_prefix": "2449929a6aaa2f26b0f0fe75814226661f06c20f62d7349ef83a2a022b67da77",
+        "size_in_bytes": 1155
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1b809455d1d8292b2f989be1db16420cb7c3aac797ad25f5848f4191af54ec81",
+        "sha256_in_prefix": "1b809455d1d8292b2f989be1db16420cb7c3aac797ad25f5848f4191af54ec81",
+        "size_in_bytes": 1058
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/connection.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0c700f38ddab30cd09204d0bdab59dc59d5c80d7bbdbe63e1ef4daef91315081",
+        "sha256_in_prefix": "0c700f38ddab30cd09204d0bdab59dc59d5c80d7bbdbe63e1ef4daef91315081",
+        "size_in_bytes": 3390
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/proxy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "df053d3eefa05a84d53aef936b1e0c56d70740a5f4dfe20980ed01b22defe781",
+        "sha256_in_prefix": "df053d3eefa05a84d53aef936b1e0c56d70740a5f4dfe20980ed01b22defe781",
+        "size_in_bytes": 1294
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/queue.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0adc713b38321502a22cf8b641703e889b3d3c28a80fa7699cd04c2122106079",
+        "sha256_in_prefix": "0adc713b38321502a22cf8b641703e889b3d3c28a80fa7699cd04c2122106079",
+        "size_in_bytes": 1013
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/request.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1c135893dee18296af134810e96f51056053b46a646fba403cec672369c96e4c",
+        "sha256_in_prefix": "1c135893dee18296af134810e96f51056053b46a646fba403cec672369c96e4c",
+        "size_in_bytes": 3302
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/response.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a9710269a06e82a8f8785f91a2f74406e9a0f87012b3ffecc753adcae35c61b9",
+        "sha256_in_prefix": "a9710269a06e82a8f8785f91a2f74406e9a0f87012b3ffecc753adcae35c61b9",
+        "size_in_bytes": 2298
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/retry.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c6dfcdef4aa05dfe7a2b8334dcdf5b4ea82b654e2f183fdcf0d6a992c990d2f3",
+        "sha256_in_prefix": "c6dfcdef4aa05dfe7a2b8334dcdf5b4ea82b654e2f183fdcf0d6a992c990d2f3",
+        "size_in_bytes": 16247
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0a1fa97c27ed473d83af7bb2c6c6ebc8bff3322c1b7f10adba63dc2de1b1de7f",
+        "sha256_in_prefix": "0a1fa97c27ed473d83af7bb2c6c6ebc8bff3322c1b7f10adba63dc2de1b1de7f",
+        "size_in_bytes": 11520
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dc71e42720c16108aaa4518513d4f352ab9b638875144e9a88d59064dd02cff6",
+        "sha256_in_prefix": "dc71e42720c16108aaa4518513d4f352ab9b638875144e9a88d59064dd02cff6",
+        "size_in_bytes": 3212
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aa339d7b6c988e460f5fb2172209c9542dfc56a5834781e9fd92454686b77e97",
+        "sha256_in_prefix": "aa339d7b6c988e460f5fb2172209c9542dfc56a5834781e9fd92454686b77e97",
+        "size_in_bytes": 7428
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/timeout.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ed0414fc4ea02eceae5e291d5ad04d4b083c9bc9e8b1840685a3d2a046ae40e1",
+        "sha256_in_prefix": "ed0414fc4ea02eceae5e291d5ad04d4b083c9bc9e8b1840685a3d2a046ae40e1",
+        "size_in_bytes": 9099
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/url.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4cd0dd1dfa0c01e72feec7cf8c265f90992c571642094f4009d0582d8e126861",
+        "sha256_in_prefix": "4cd0dd1dfa0c01e72feec7cf8c265f90992c571642094f4009d0582d8e126861",
+        "size_in_bytes": 10652
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/__pycache__/wait.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cb7efcd3cad7ff3a99a44546b200090f90ba3e8bb6fdcbc2748cb96f6124cccf",
+        "sha256_in_prefix": "cb7efcd3cad7ff3a99a44546b200090f90ba3e8bb6fdcbc2748cb96f6124cccf",
+        "size_in_bytes": 3081
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/connection.py",
+        "path_type": "hardlink",
+        "sha256": "e4bc760753d6dbd2b1067d93d3190dd420604416b780654904aa10a11a201159",
+        "sha256_in_prefix": "e4bc760753d6dbd2b1067d93d3190dd420604416b780654904aa10a11a201159",
+        "size_in_bytes": 4901
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/proxy.py",
+        "path_type": "hardlink",
+        "sha256": "cd4bcf3c226ba7a74e17437818055b39c97aa3ee2e5ca4ab1a24e492be6f512e",
+        "sha256_in_prefix": "cd4bcf3c226ba7a74e17437818055b39c97aa3ee2e5ca4ab1a24e492be6f512e",
+        "size_in_bytes": 1605
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/queue.py",
+        "path_type": "hardlink",
+        "sha256": "9d1817f3f797fbf564bf1a17d3de905a8cfc3ecd101d4004c482c263fecf9dc3",
+        "sha256_in_prefix": "9d1817f3f797fbf564bf1a17d3de905a8cfc3ecd101d4004c482c263fecf9dc3",
+        "size_in_bytes": 498
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/request.py",
+        "path_type": "hardlink",
+        "sha256": "0b4394b76b5c53a2d189027b61834ff46bcfad2be5ef388805e910fb99e50599",
+        "sha256_in_prefix": "0b4394b76b5c53a2d189027b61834ff46bcfad2be5ef388805e910fb99e50599",
+        "size_in_bytes": 3997
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/response.py",
+        "path_type": "hardlink",
+        "sha256": "189a60dc4822f6a6895d1c01879c2ff8c36e4566a7e4122ee34a117a8c563f6f",
+        "sha256_in_prefix": "189a60dc4822f6a6895d1c01879c2ff8c36e4566a7e4122ee34a117a8c563f6f",
+        "size_in_bytes": 3510
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/retry.py",
+        "path_type": "hardlink",
+        "sha256": "e8436f399f0f043ce1f24822c69aa5f6522b6f67711fe93b66605a9c9176360e",
+        "sha256_in_prefix": "e8436f399f0f043ce1f24822c69aa5f6522b6f67711fe93b66605a9c9176360e",
+        "size_in_bytes": 22050
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/ssl_.py",
+        "path_type": "hardlink",
+        "sha256": "403bae4f13d20a3d6b62d678c690fb531fabdb44c3e74687caa2b2850ec1ab80",
+        "sha256_in_prefix": "403bae4f13d20a3d6b62d678c690fb531fabdb44c3e74687caa2b2850ec1ab80",
+        "size_in_bytes": 17460
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/ssl_match_hostname.py",
+        "path_type": "hardlink",
+        "sha256": "22be1c65512398093c8140081d64a2ef0b4e3bcdd4098001636c450f5425fd60",
+        "sha256_in_prefix": "22be1c65512398093c8140081d64a2ef0b4e3bcdd4098001636c450f5425fd60",
+        "size_in_bytes": 5758
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/ssltransport.py",
+        "path_type": "hardlink",
+        "sha256": "340faee6b313ac3143142f10cd129410a306d39eb584e0f8a814ebdd9e29bfa1",
+        "sha256_in_prefix": "340faee6b313ac3143142f10cd129410a306d39eb584e0f8a814ebdd9e29bfa1",
+        "size_in_bytes": 6895
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/timeout.py",
+        "path_type": "hardlink",
+        "sha256": "730ab874c93cee624748192d2b59a2609fbce46fb74f74664f6d2fed2142a67a",
+        "sha256_in_prefix": "730ab874c93cee624748192d2b59a2609fbce46fb74f74664f6d2fed2142a67a",
+        "size_in_bytes": 10168
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/url.py",
+        "path_type": "hardlink",
+        "sha256": "942004ecce66c80f040dd5b4b09bb2c9985507d2bf8f7f258d684702715a5a81",
+        "sha256_in_prefix": "942004ecce66c80f040dd5b4b09bb2c9985507d2bf8f7f258d684702715a5a81",
+        "size_in_bytes": 14296
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/urllib3/util/wait.py",
+        "path_type": "hardlink",
+        "sha256": "7ce5f4fdf6a8cc6d8fee25688d0a04d666f277078dc93726fa15c47c5ad3b4b2",
+        "sha256_in_prefix": "7ce5f4fdf6a8cc6d8fee25688d0a04d666f277078dc93726fa15c47c5ad3b4b2",
+        "size_in_bytes": 5403
+      },
+      {
+        "_path": "Lib/site-packages/pip/_vendor/vendor.txt",
+        "path_type": "hardlink",
+        "sha256": "116f84ddc1395c402d545cc62278a402b38c0f118fd032d45b35e96384597c56",
+        "sha256_in_prefix": "116f84ddc1395c402d545cc62278a402b38c0f118fd032d45b35e96384597c56",
+        "size_in_bytes": 333
+      },
+      {
+        "_path": "Lib/site-packages/pip/py.typed",
+        "path_type": "hardlink",
+        "sha256": "10156fbcf4539ff788a73e5ee50ced48276b317ed0c1ded53fddd14a82256762",
+        "sha256_in_prefix": "10156fbcf4539ff788a73e5ee50ced48276b317ed0c1ded53fddd14a82256762",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "Scripts/pip-script.py",
+        "path_type": "hardlink",
+        "sha256": "b3d5aa165133652298897142f1e5edb0948b2f6eb2b03c04aeec6ad0a3c90b0d",
+        "sha256_in_prefix": "b3d5aa165133652298897142f1e5edb0948b2f6eb2b03c04aeec6ad0a3c90b0d",
+        "size_in_bytes": 216
+      },
+      {
+        "_path": "Scripts/pip.exe",
+        "path_type": "hardlink",
+        "sha256": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "sha256_in_prefix": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "size_in_bytes": 54032
+      },
+      {
+        "_path": "Scripts/pip3-script.py",
+        "path_type": "hardlink",
+        "sha256": "b3d5aa165133652298897142f1e5edb0948b2f6eb2b03c04aeec6ad0a3c90b0d",
+        "sha256_in_prefix": "b3d5aa165133652298897142f1e5edb0948b2f6eb2b03c04aeec6ad0a3c90b0d",
+        "size_in_bytes": 216
+      },
+      {
+        "_path": "Scripts/pip3.exe",
+        "path_type": "hardlink",
+        "sha256": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "sha256_in_prefix": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "size_in_bytes": 54032
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "e4fb357da0e58f1590da95fead2741f311e3103106389ab544448f4192acc9de",
+  "size": 2597649,
+  "subdir": "win-64",
+  "timestamp": 1737992218069,
+  "track_features": "",
+  "url": "https://repo.anaconda.com/pkgs/main/win-64/pip-25.0-py39haa95532_0.conda",
+  "version": "25.0"
+}
\ No newline at end of file
diff --git a/marketing/conda-meta/python-3.9.21-h8205438_1.json b/marketing/conda-meta/python-3.9.21-h8205438_1.json
new file mode 100644
index 0000000000000000000000000000000000000000..6e6426a137924b36117d31cc4fa8b26825d58037
--- /dev/null
+++ b/marketing/conda-meta/python-3.9.21-h8205438_1.json
@@ -0,0 +1,29040 @@
+{
+  "build": "h8205438_1",
+  "build_number": 1,
+  "channel": "https://repo.anaconda.com/pkgs/main/win-64",
+  "constrains": [],
+  "depends": [
+    "openssl >=3.0.15,<4.0a0",
+    "sqlite >=3.45.3,<4.0a0",
+    "tzdata",
+    "vc >=14.2,<15.0a0",
+    "vs2015_runtime >=14.29.30133,<15.0a0",
+    "pip"
+  ],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\python-3.9.21-h8205438_1",
+  "features": "",
+  "files": [
+    "DLLs/_asyncio.pyd",
+    "DLLs/_bz2.pyd",
+    "DLLs/_ctypes.pyd",
+    "DLLs/_ctypes_test.pyd",
+    "DLLs/_decimal.pyd",
+    "DLLs/_elementtree.pyd",
+    "DLLs/_hashlib.pyd",
+    "DLLs/_lzma.pyd",
+    "DLLs/_msi.pyd",
+    "DLLs/_multiprocessing.pyd",
+    "DLLs/_overlapped.pyd",
+    "DLLs/_queue.pyd",
+    "DLLs/_socket.pyd",
+    "DLLs/_sqlite3.pyd",
+    "DLLs/_ssl.pyd",
+    "DLLs/_testbuffer.pyd",
+    "DLLs/_testcapi.pyd",
+    "DLLs/_testconsole.pyd",
+    "DLLs/_testimportmultiple.pyd",
+    "DLLs/_testinternalcapi.pyd",
+    "DLLs/_testmultiphase.pyd",
+    "DLLs/_tkinter.pyd",
+    "DLLs/_uuid.pyd",
+    "DLLs/_zoneinfo.pyd",
+    "DLLs/libffi-7.dll",
+    "DLLs/py.ico",
+    "DLLs/pyc.ico",
+    "DLLs/pyexpat.pyd",
+    "DLLs/select.pyd",
+    "DLLs/tcl86t.dll",
+    "DLLs/tk86t.dll",
+    "DLLs/unicodedata.pyd",
+    "DLLs/winsound.pyd",
+    "LICENSE_PYTHON.txt",
+    "Lib/__future__.py",
+    "Lib/__phello__.foo.py",
+    "Lib/__pycache__/__future__.cpython-39.pyc",
+    "Lib/__pycache__/__phello__.foo.cpython-39.pyc",
+    "Lib/__pycache__/_aix_support.cpython-39.pyc",
+    "Lib/__pycache__/_bootlocale.cpython-39.pyc",
+    "Lib/__pycache__/_bootsubprocess.cpython-39.pyc",
+    "Lib/__pycache__/_collections_abc.cpython-39.pyc",
+    "Lib/__pycache__/_compat_pickle.cpython-39.pyc",
+    "Lib/__pycache__/_compression.cpython-39.pyc",
+    "Lib/__pycache__/_markupbase.cpython-39.pyc",
+    "Lib/__pycache__/_osx_support.cpython-39.pyc",
+    "Lib/__pycache__/_py_abc.cpython-39.pyc",
+    "Lib/__pycache__/_pydecimal.cpython-39.pyc",
+    "Lib/__pycache__/_pyio.cpython-39.pyc",
+    "Lib/__pycache__/_sitebuiltins.cpython-39.pyc",
+    "Lib/__pycache__/_strptime.cpython-39.pyc",
+    "Lib/__pycache__/_threading_local.cpython-39.pyc",
+    "Lib/__pycache__/_weakrefset.cpython-39.pyc",
+    "Lib/__pycache__/abc.cpython-39.pyc",
+    "Lib/__pycache__/aifc.cpython-39.pyc",
+    "Lib/__pycache__/antigravity.cpython-39.pyc",
+    "Lib/__pycache__/argparse.cpython-39.pyc",
+    "Lib/__pycache__/ast.cpython-39.pyc",
+    "Lib/__pycache__/asynchat.cpython-39.pyc",
+    "Lib/__pycache__/asyncore.cpython-39.pyc",
+    "Lib/__pycache__/base64.cpython-39.pyc",
+    "Lib/__pycache__/bdb.cpython-39.pyc",
+    "Lib/__pycache__/binhex.cpython-39.pyc",
+    "Lib/__pycache__/bisect.cpython-39.pyc",
+    "Lib/__pycache__/bz2.cpython-39.pyc",
+    "Lib/__pycache__/cProfile.cpython-39.pyc",
+    "Lib/__pycache__/calendar.cpython-39.pyc",
+    "Lib/__pycache__/cgi.cpython-39.pyc",
+    "Lib/__pycache__/cgitb.cpython-39.pyc",
+    "Lib/__pycache__/chunk.cpython-39.pyc",
+    "Lib/__pycache__/cmd.cpython-39.pyc",
+    "Lib/__pycache__/code.cpython-39.pyc",
+    "Lib/__pycache__/codecs.cpython-39.pyc",
+    "Lib/__pycache__/codeop.cpython-39.pyc",
+    "Lib/__pycache__/colorsys.cpython-39.pyc",
+    "Lib/__pycache__/compileall.cpython-39.pyc",
+    "Lib/__pycache__/configparser.cpython-39.pyc",
+    "Lib/__pycache__/contextlib.cpython-39.pyc",
+    "Lib/__pycache__/contextvars.cpython-39.pyc",
+    "Lib/__pycache__/copy.cpython-39.pyc",
+    "Lib/__pycache__/copyreg.cpython-39.pyc",
+    "Lib/__pycache__/crypt.cpython-39.pyc",
+    "Lib/__pycache__/csv.cpython-39.pyc",
+    "Lib/__pycache__/dataclasses.cpython-39.pyc",
+    "Lib/__pycache__/datetime.cpython-39.pyc",
+    "Lib/__pycache__/decimal.cpython-39.pyc",
+    "Lib/__pycache__/difflib.cpython-39.pyc",
+    "Lib/__pycache__/dis.cpython-39.pyc",
+    "Lib/__pycache__/doctest.cpython-39.pyc",
+    "Lib/__pycache__/enum.cpython-39.pyc",
+    "Lib/__pycache__/filecmp.cpython-39.pyc",
+    "Lib/__pycache__/fileinput.cpython-39.pyc",
+    "Lib/__pycache__/fnmatch.cpython-39.pyc",
+    "Lib/__pycache__/formatter.cpython-39.pyc",
+    "Lib/__pycache__/fractions.cpython-39.pyc",
+    "Lib/__pycache__/ftplib.cpython-39.pyc",
+    "Lib/__pycache__/functools.cpython-39.pyc",
+    "Lib/__pycache__/genericpath.cpython-39.pyc",
+    "Lib/__pycache__/getopt.cpython-39.pyc",
+    "Lib/__pycache__/getpass.cpython-39.pyc",
+    "Lib/__pycache__/gettext.cpython-39.pyc",
+    "Lib/__pycache__/glob.cpython-39.pyc",
+    "Lib/__pycache__/graphlib.cpython-39.pyc",
+    "Lib/__pycache__/gzip.cpython-39.pyc",
+    "Lib/__pycache__/hashlib.cpython-39.pyc",
+    "Lib/__pycache__/heapq.cpython-39.pyc",
+    "Lib/__pycache__/hmac.cpython-39.pyc",
+    "Lib/__pycache__/imaplib.cpython-39.pyc",
+    "Lib/__pycache__/imghdr.cpython-39.pyc",
+    "Lib/__pycache__/imp.cpython-39.pyc",
+    "Lib/__pycache__/inspect.cpython-39.pyc",
+    "Lib/__pycache__/io.cpython-39.pyc",
+    "Lib/__pycache__/ipaddress.cpython-39.pyc",
+    "Lib/__pycache__/keyword.cpython-39.pyc",
+    "Lib/__pycache__/linecache.cpython-39.pyc",
+    "Lib/__pycache__/locale.cpython-39.pyc",
+    "Lib/__pycache__/lzma.cpython-39.pyc",
+    "Lib/__pycache__/mailbox.cpython-39.pyc",
+    "Lib/__pycache__/mailcap.cpython-39.pyc",
+    "Lib/__pycache__/mimetypes.cpython-39.pyc",
+    "Lib/__pycache__/modulefinder.cpython-39.pyc",
+    "Lib/__pycache__/netrc.cpython-39.pyc",
+    "Lib/__pycache__/nntplib.cpython-39.pyc",
+    "Lib/__pycache__/ntpath.cpython-39.pyc",
+    "Lib/__pycache__/nturl2path.cpython-39.pyc",
+    "Lib/__pycache__/numbers.cpython-39.pyc",
+    "Lib/__pycache__/opcode.cpython-39.pyc",
+    "Lib/__pycache__/operator.cpython-39.pyc",
+    "Lib/__pycache__/optparse.cpython-39.pyc",
+    "Lib/__pycache__/os.cpython-39.pyc",
+    "Lib/__pycache__/pathlib.cpython-39.pyc",
+    "Lib/__pycache__/pdb.cpython-39.pyc",
+    "Lib/__pycache__/pickle.cpython-39.pyc",
+    "Lib/__pycache__/pickletools.cpython-39.pyc",
+    "Lib/__pycache__/pipes.cpython-39.pyc",
+    "Lib/__pycache__/pkgutil.cpython-39.pyc",
+    "Lib/__pycache__/platform.cpython-39.pyc",
+    "Lib/__pycache__/plistlib.cpython-39.pyc",
+    "Lib/__pycache__/poplib.cpython-39.pyc",
+    "Lib/__pycache__/posixpath.cpython-39.pyc",
+    "Lib/__pycache__/pprint.cpython-39.pyc",
+    "Lib/__pycache__/profile.cpython-39.pyc",
+    "Lib/__pycache__/pstats.cpython-39.pyc",
+    "Lib/__pycache__/pty.cpython-39.pyc",
+    "Lib/__pycache__/py_compile.cpython-39.pyc",
+    "Lib/__pycache__/pyclbr.cpython-39.pyc",
+    "Lib/__pycache__/pydoc.cpython-39.pyc",
+    "Lib/__pycache__/queue.cpython-39.pyc",
+    "Lib/__pycache__/quopri.cpython-39.pyc",
+    "Lib/__pycache__/random.cpython-39.pyc",
+    "Lib/__pycache__/re.cpython-39.pyc",
+    "Lib/__pycache__/reprlib.cpython-39.pyc",
+    "Lib/__pycache__/rlcompleter.cpython-39.pyc",
+    "Lib/__pycache__/runpy.cpython-39.pyc",
+    "Lib/__pycache__/sched.cpython-39.pyc",
+    "Lib/__pycache__/secrets.cpython-39.pyc",
+    "Lib/__pycache__/selectors.cpython-39.pyc",
+    "Lib/__pycache__/shelve.cpython-39.pyc",
+    "Lib/__pycache__/shlex.cpython-39.pyc",
+    "Lib/__pycache__/shutil.cpython-39.pyc",
+    "Lib/__pycache__/signal.cpython-39.pyc",
+    "Lib/__pycache__/site.cpython-39.pyc",
+    "Lib/__pycache__/smtpd.cpython-39.pyc",
+    "Lib/__pycache__/smtplib.cpython-39.pyc",
+    "Lib/__pycache__/sndhdr.cpython-39.pyc",
+    "Lib/__pycache__/socket.cpython-39.pyc",
+    "Lib/__pycache__/socketserver.cpython-39.pyc",
+    "Lib/__pycache__/sre_compile.cpython-39.pyc",
+    "Lib/__pycache__/sre_constants.cpython-39.pyc",
+    "Lib/__pycache__/sre_parse.cpython-39.pyc",
+    "Lib/__pycache__/ssl.cpython-39.pyc",
+    "Lib/__pycache__/stat.cpython-39.pyc",
+    "Lib/__pycache__/statistics.cpython-39.pyc",
+    "Lib/__pycache__/string.cpython-39.pyc",
+    "Lib/__pycache__/stringprep.cpython-39.pyc",
+    "Lib/__pycache__/struct.cpython-39.pyc",
+    "Lib/__pycache__/subprocess.cpython-39.pyc",
+    "Lib/__pycache__/sunau.cpython-39.pyc",
+    "Lib/__pycache__/symbol.cpython-39.pyc",
+    "Lib/__pycache__/symtable.cpython-39.pyc",
+    "Lib/__pycache__/sysconfig.cpython-39.pyc",
+    "Lib/__pycache__/tabnanny.cpython-39.pyc",
+    "Lib/__pycache__/tarfile.cpython-39.pyc",
+    "Lib/__pycache__/telnetlib.cpython-39.pyc",
+    "Lib/__pycache__/tempfile.cpython-39.pyc",
+    "Lib/__pycache__/textwrap.cpython-39.pyc",
+    "Lib/__pycache__/this.cpython-39.pyc",
+    "Lib/__pycache__/threading.cpython-39.pyc",
+    "Lib/__pycache__/timeit.cpython-39.pyc",
+    "Lib/__pycache__/token.cpython-39.pyc",
+    "Lib/__pycache__/tokenize.cpython-39.pyc",
+    "Lib/__pycache__/trace.cpython-39.pyc",
+    "Lib/__pycache__/traceback.cpython-39.pyc",
+    "Lib/__pycache__/tracemalloc.cpython-39.pyc",
+    "Lib/__pycache__/tty.cpython-39.pyc",
+    "Lib/__pycache__/turtle.cpython-39.pyc",
+    "Lib/__pycache__/types.cpython-39.pyc",
+    "Lib/__pycache__/typing.cpython-39.pyc",
+    "Lib/__pycache__/uu.cpython-39.pyc",
+    "Lib/__pycache__/uuid.cpython-39.pyc",
+    "Lib/__pycache__/warnings.cpython-39.pyc",
+    "Lib/__pycache__/wave.cpython-39.pyc",
+    "Lib/__pycache__/weakref.cpython-39.pyc",
+    "Lib/__pycache__/webbrowser.cpython-39.pyc",
+    "Lib/__pycache__/xdrlib.cpython-39.pyc",
+    "Lib/__pycache__/zipapp.cpython-39.pyc",
+    "Lib/__pycache__/zipfile.cpython-39.pyc",
+    "Lib/__pycache__/zipimport.cpython-39.pyc",
+    "Lib/_aix_support.py",
+    "Lib/_bootlocale.py",
+    "Lib/_bootsubprocess.py",
+    "Lib/_collections_abc.py",
+    "Lib/_compat_pickle.py",
+    "Lib/_compression.py",
+    "Lib/_markupbase.py",
+    "Lib/_osx_support.py",
+    "Lib/_py_abc.py",
+    "Lib/_pydecimal.py",
+    "Lib/_pyio.py",
+    "Lib/_sitebuiltins.py",
+    "Lib/_strptime.py",
+    "Lib/_threading_local.py",
+    "Lib/_weakrefset.py",
+    "Lib/abc.py",
+    "Lib/aifc.py",
+    "Lib/antigravity.py",
+    "Lib/argparse.py",
+    "Lib/ast.py",
+    "Lib/asynchat.py",
+    "Lib/asyncio/__init__.py",
+    "Lib/asyncio/__main__.py",
+    "Lib/asyncio/__pycache__/__init__.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/__main__.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/base_events.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/base_futures.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/base_subprocess.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/base_tasks.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/constants.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/coroutines.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/events.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/exceptions.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/format_helpers.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/futures.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/locks.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/log.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/proactor_events.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/protocols.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/queues.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/runners.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/selector_events.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/sslproto.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/staggered.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/streams.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/subprocess.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/tasks.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/threads.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/transports.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/trsock.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/unix_events.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/windows_events.cpython-39.pyc",
+    "Lib/asyncio/__pycache__/windows_utils.cpython-39.pyc",
+    "Lib/asyncio/base_events.py",
+    "Lib/asyncio/base_futures.py",
+    "Lib/asyncio/base_subprocess.py",
+    "Lib/asyncio/base_tasks.py",
+    "Lib/asyncio/constants.py",
+    "Lib/asyncio/coroutines.py",
+    "Lib/asyncio/events.py",
+    "Lib/asyncio/exceptions.py",
+    "Lib/asyncio/format_helpers.py",
+    "Lib/asyncio/futures.py",
+    "Lib/asyncio/locks.py",
+    "Lib/asyncio/log.py",
+    "Lib/asyncio/proactor_events.py",
+    "Lib/asyncio/protocols.py",
+    "Lib/asyncio/queues.py",
+    "Lib/asyncio/runners.py",
+    "Lib/asyncio/selector_events.py",
+    "Lib/asyncio/sslproto.py",
+    "Lib/asyncio/staggered.py",
+    "Lib/asyncio/streams.py",
+    "Lib/asyncio/subprocess.py",
+    "Lib/asyncio/tasks.py",
+    "Lib/asyncio/threads.py",
+    "Lib/asyncio/transports.py",
+    "Lib/asyncio/trsock.py",
+    "Lib/asyncio/unix_events.py",
+    "Lib/asyncio/windows_events.py",
+    "Lib/asyncio/windows_utils.py",
+    "Lib/asyncore.py",
+    "Lib/base64.py",
+    "Lib/bdb.py",
+    "Lib/binhex.py",
+    "Lib/bisect.py",
+    "Lib/bz2.py",
+    "Lib/cProfile.py",
+    "Lib/calendar.py",
+    "Lib/cgi.py",
+    "Lib/cgitb.py",
+    "Lib/chunk.py",
+    "Lib/cmd.py",
+    "Lib/code.py",
+    "Lib/codecs.py",
+    "Lib/codeop.py",
+    "Lib/collections/__init__.py",
+    "Lib/collections/__pycache__/__init__.cpython-39.pyc",
+    "Lib/collections/__pycache__/abc.cpython-39.pyc",
+    "Lib/collections/abc.py",
+    "Lib/colorsys.py",
+    "Lib/compileall.py",
+    "Lib/concurrent/__init__.py",
+    "Lib/concurrent/__pycache__/__init__.cpython-39.pyc",
+    "Lib/concurrent/futures/__init__.py",
+    "Lib/concurrent/futures/__pycache__/__init__.cpython-39.pyc",
+    "Lib/concurrent/futures/__pycache__/_base.cpython-39.pyc",
+    "Lib/concurrent/futures/__pycache__/process.cpython-39.pyc",
+    "Lib/concurrent/futures/__pycache__/thread.cpython-39.pyc",
+    "Lib/concurrent/futures/_base.py",
+    "Lib/concurrent/futures/process.py",
+    "Lib/concurrent/futures/thread.py",
+    "Lib/configparser.py",
+    "Lib/contextlib.py",
+    "Lib/contextvars.py",
+    "Lib/copy.py",
+    "Lib/copyreg.py",
+    "Lib/crypt.py",
+    "Lib/csv.py",
+    "Lib/ctypes/__init__.py",
+    "Lib/ctypes/__pycache__/__init__.cpython-39.pyc",
+    "Lib/ctypes/__pycache__/_aix.cpython-39.pyc",
+    "Lib/ctypes/__pycache__/_endian.cpython-39.pyc",
+    "Lib/ctypes/__pycache__/util.cpython-39.pyc",
+    "Lib/ctypes/__pycache__/wintypes.cpython-39.pyc",
+    "Lib/ctypes/_aix.py",
+    "Lib/ctypes/_endian.py",
+    "Lib/ctypes/macholib/README.ctypes",
+    "Lib/ctypes/macholib/__init__.py",
+    "Lib/ctypes/macholib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/ctypes/macholib/__pycache__/dyld.cpython-39.pyc",
+    "Lib/ctypes/macholib/__pycache__/dylib.cpython-39.pyc",
+    "Lib/ctypes/macholib/__pycache__/framework.cpython-39.pyc",
+    "Lib/ctypes/macholib/dyld.py",
+    "Lib/ctypes/macholib/dylib.py",
+    "Lib/ctypes/macholib/fetch_macholib",
+    "Lib/ctypes/macholib/fetch_macholib.bat",
+    "Lib/ctypes/macholib/framework.py",
+    "Lib/ctypes/test/__init__.py",
+    "Lib/ctypes/test/__main__.py",
+    "Lib/ctypes/test/__pycache__/__init__.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/__main__.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_anon.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_array_in_pointer.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_arrays.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_as_parameter.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_bitfields.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_buffers.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_bytes.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_byteswap.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_callbacks.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_cast.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_cfuncs.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_checkretval.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_delattr.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_errno.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_find.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_frombuffer.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_funcptr.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_functions.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_incomplete.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_init.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_internals.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_keeprefs.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_libc.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_loading.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_macholib.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_memfunctions.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_numbers.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_objects.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_parameters.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_pep3118.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_pickling.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_pointers.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_prototypes.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_python_api.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_random_things.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_refcounts.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_repr.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_returnfuncptrs.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_simplesubclasses.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_sizes.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_slicing.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_stringptr.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_strings.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_struct_fields.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_structures.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_unaligned_structures.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_unicode.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_values.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_varsize_struct.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_win32.cpython-39.pyc",
+    "Lib/ctypes/test/__pycache__/test_wintypes.cpython-39.pyc",
+    "Lib/ctypes/test/test_anon.py",
+    "Lib/ctypes/test/test_array_in_pointer.py",
+    "Lib/ctypes/test/test_arrays.py",
+    "Lib/ctypes/test/test_as_parameter.py",
+    "Lib/ctypes/test/test_bitfields.py",
+    "Lib/ctypes/test/test_buffers.py",
+    "Lib/ctypes/test/test_bytes.py",
+    "Lib/ctypes/test/test_byteswap.py",
+    "Lib/ctypes/test/test_callbacks.py",
+    "Lib/ctypes/test/test_cast.py",
+    "Lib/ctypes/test/test_cfuncs.py",
+    "Lib/ctypes/test/test_checkretval.py",
+    "Lib/ctypes/test/test_delattr.py",
+    "Lib/ctypes/test/test_errno.py",
+    "Lib/ctypes/test/test_find.py",
+    "Lib/ctypes/test/test_frombuffer.py",
+    "Lib/ctypes/test/test_funcptr.py",
+    "Lib/ctypes/test/test_functions.py",
+    "Lib/ctypes/test/test_incomplete.py",
+    "Lib/ctypes/test/test_init.py",
+    "Lib/ctypes/test/test_internals.py",
+    "Lib/ctypes/test/test_keeprefs.py",
+    "Lib/ctypes/test/test_libc.py",
+    "Lib/ctypes/test/test_loading.py",
+    "Lib/ctypes/test/test_macholib.py",
+    "Lib/ctypes/test/test_memfunctions.py",
+    "Lib/ctypes/test/test_numbers.py",
+    "Lib/ctypes/test/test_objects.py",
+    "Lib/ctypes/test/test_parameters.py",
+    "Lib/ctypes/test/test_pep3118.py",
+    "Lib/ctypes/test/test_pickling.py",
+    "Lib/ctypes/test/test_pointers.py",
+    "Lib/ctypes/test/test_prototypes.py",
+    "Lib/ctypes/test/test_python_api.py",
+    "Lib/ctypes/test/test_random_things.py",
+    "Lib/ctypes/test/test_refcounts.py",
+    "Lib/ctypes/test/test_repr.py",
+    "Lib/ctypes/test/test_returnfuncptrs.py",
+    "Lib/ctypes/test/test_simplesubclasses.py",
+    "Lib/ctypes/test/test_sizes.py",
+    "Lib/ctypes/test/test_slicing.py",
+    "Lib/ctypes/test/test_stringptr.py",
+    "Lib/ctypes/test/test_strings.py",
+    "Lib/ctypes/test/test_struct_fields.py",
+    "Lib/ctypes/test/test_structures.py",
+    "Lib/ctypes/test/test_unaligned_structures.py",
+    "Lib/ctypes/test/test_unicode.py",
+    "Lib/ctypes/test/test_values.py",
+    "Lib/ctypes/test/test_varsize_struct.py",
+    "Lib/ctypes/test/test_win32.py",
+    "Lib/ctypes/test/test_wintypes.py",
+    "Lib/ctypes/util.py",
+    "Lib/ctypes/wintypes.py",
+    "Lib/curses/__init__.py",
+    "Lib/curses/__pycache__/__init__.cpython-39.pyc",
+    "Lib/curses/__pycache__/ascii.cpython-39.pyc",
+    "Lib/curses/__pycache__/has_key.cpython-39.pyc",
+    "Lib/curses/__pycache__/panel.cpython-39.pyc",
+    "Lib/curses/__pycache__/textpad.cpython-39.pyc",
+    "Lib/curses/ascii.py",
+    "Lib/curses/has_key.py",
+    "Lib/curses/panel.py",
+    "Lib/curses/textpad.py",
+    "Lib/dataclasses.py",
+    "Lib/datetime.py",
+    "Lib/dbm/__init__.py",
+    "Lib/dbm/__pycache__/__init__.cpython-39.pyc",
+    "Lib/dbm/__pycache__/dumb.cpython-39.pyc",
+    "Lib/dbm/__pycache__/gnu.cpython-39.pyc",
+    "Lib/dbm/__pycache__/ndbm.cpython-39.pyc",
+    "Lib/dbm/dumb.py",
+    "Lib/dbm/gnu.py",
+    "Lib/dbm/ndbm.py",
+    "Lib/decimal.py",
+    "Lib/difflib.py",
+    "Lib/dis.py",
+    "Lib/distutils/README",
+    "Lib/distutils/__init__.py",
+    "Lib/distutils/__pycache__/__init__.cpython-39.pyc",
+    "Lib/distutils/__pycache__/_msvccompiler.cpython-39.pyc",
+    "Lib/distutils/__pycache__/archive_util.cpython-39.pyc",
+    "Lib/distutils/__pycache__/bcppcompiler.cpython-39.pyc",
+    "Lib/distutils/__pycache__/ccompiler.cpython-39.pyc",
+    "Lib/distutils/__pycache__/cmd.cpython-39.pyc",
+    "Lib/distutils/__pycache__/config.cpython-39.pyc",
+    "Lib/distutils/__pycache__/core.cpython-39.pyc",
+    "Lib/distutils/__pycache__/cygwinccompiler.cpython-39.pyc",
+    "Lib/distutils/__pycache__/debug.cpython-39.pyc",
+    "Lib/distutils/__pycache__/dep_util.cpython-39.pyc",
+    "Lib/distutils/__pycache__/dir_util.cpython-39.pyc",
+    "Lib/distutils/__pycache__/dist.cpython-39.pyc",
+    "Lib/distutils/__pycache__/errors.cpython-39.pyc",
+    "Lib/distutils/__pycache__/extension.cpython-39.pyc",
+    "Lib/distutils/__pycache__/fancy_getopt.cpython-39.pyc",
+    "Lib/distutils/__pycache__/file_util.cpython-39.pyc",
+    "Lib/distutils/__pycache__/filelist.cpython-39.pyc",
+    "Lib/distutils/__pycache__/log.cpython-39.pyc",
+    "Lib/distutils/__pycache__/msvc9compiler.cpython-39.pyc",
+    "Lib/distutils/__pycache__/msvccompiler.cpython-39.pyc",
+    "Lib/distutils/__pycache__/spawn.cpython-39.pyc",
+    "Lib/distutils/__pycache__/sysconfig.cpython-39.pyc",
+    "Lib/distutils/__pycache__/text_file.cpython-39.pyc",
+    "Lib/distutils/__pycache__/unixccompiler.cpython-39.pyc",
+    "Lib/distutils/__pycache__/util.cpython-39.pyc",
+    "Lib/distutils/__pycache__/version.cpython-39.pyc",
+    "Lib/distutils/__pycache__/versionpredicate.cpython-39.pyc",
+    "Lib/distutils/_msvccompiler.py",
+    "Lib/distutils/archive_util.py",
+    "Lib/distutils/bcppcompiler.py",
+    "Lib/distutils/ccompiler.py",
+    "Lib/distutils/cmd.py",
+    "Lib/distutils/command/__init__.py",
+    "Lib/distutils/command/__pycache__/__init__.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/bdist.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/bdist_dumb.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/bdist_msi.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/bdist_rpm.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/bdist_wininst.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/build.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/build_clib.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/build_ext.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/build_py.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/build_scripts.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/check.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/clean.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/config.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/install.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/install_data.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/install_egg_info.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/install_headers.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/install_lib.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/install_scripts.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/register.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/sdist.cpython-39.pyc",
+    "Lib/distutils/command/__pycache__/upload.cpython-39.pyc",
+    "Lib/distutils/command/bdist.py",
+    "Lib/distutils/command/bdist_dumb.py",
+    "Lib/distutils/command/bdist_msi.py",
+    "Lib/distutils/command/bdist_rpm.py",
+    "Lib/distutils/command/bdist_wininst.py",
+    "Lib/distutils/command/build.py",
+    "Lib/distutils/command/build_clib.py",
+    "Lib/distutils/command/build_ext.py",
+    "Lib/distutils/command/build_py.py",
+    "Lib/distutils/command/build_scripts.py",
+    "Lib/distutils/command/check.py",
+    "Lib/distutils/command/clean.py",
+    "Lib/distutils/command/command_template",
+    "Lib/distutils/command/config.py",
+    "Lib/distutils/command/install.py",
+    "Lib/distutils/command/install_data.py",
+    "Lib/distutils/command/install_egg_info.py",
+    "Lib/distutils/command/install_headers.py",
+    "Lib/distutils/command/install_lib.py",
+    "Lib/distutils/command/install_scripts.py",
+    "Lib/distutils/command/register.py",
+    "Lib/distutils/command/sdist.py",
+    "Lib/distutils/command/upload.py",
+    "Lib/distutils/command/wininst-10.0-amd64.exe",
+    "Lib/distutils/command/wininst-10.0.exe",
+    "Lib/distutils/command/wininst-14.0-amd64.exe",
+    "Lib/distutils/command/wininst-14.0.exe",
+    "Lib/distutils/command/wininst-6.0.exe",
+    "Lib/distutils/command/wininst-7.1.exe",
+    "Lib/distutils/command/wininst-8.0.exe",
+    "Lib/distutils/command/wininst-9.0-amd64.exe",
+    "Lib/distutils/command/wininst-9.0.exe",
+    "Lib/distutils/config.py",
+    "Lib/distutils/core.py",
+    "Lib/distutils/cygwinccompiler.py",
+    "Lib/distutils/debug.py",
+    "Lib/distutils/dep_util.py",
+    "Lib/distutils/dir_util.py",
+    "Lib/distutils/dist.py",
+    "Lib/distutils/errors.py",
+    "Lib/distutils/extension.py",
+    "Lib/distutils/fancy_getopt.py",
+    "Lib/distutils/file_util.py",
+    "Lib/distutils/filelist.py",
+    "Lib/distutils/log.py",
+    "Lib/distutils/msvc9compiler.py",
+    "Lib/distutils/msvccompiler.py",
+    "Lib/distutils/spawn.py",
+    "Lib/distutils/sysconfig.py",
+    "Lib/distutils/tests/Setup.sample",
+    "Lib/distutils/tests/__init__.py",
+    "Lib/distutils/tests/__pycache__/__init__.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/support.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_archive_util.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_bdist.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_bdist_dumb.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_bdist_msi.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_bdist_rpm.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_bdist_wininst.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_build.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_build_clib.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_build_ext.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_build_py.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_build_scripts.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_check.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_clean.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_cmd.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_config.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_config_cmd.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_core.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_cygwinccompiler.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_dep_util.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_dir_util.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_dist.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_extension.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_file_util.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_filelist.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_install.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_install_data.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_install_headers.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_install_lib.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_install_scripts.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_log.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_msvc9compiler.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_msvccompiler.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_register.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_sdist.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_spawn.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_sysconfig.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_text_file.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_unixccompiler.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_upload.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_util.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_version.cpython-39.pyc",
+    "Lib/distutils/tests/__pycache__/test_versionpredicate.cpython-39.pyc",
+    "Lib/distutils/tests/includetest.rst",
+    "Lib/distutils/tests/support.py",
+    "Lib/distutils/tests/test_archive_util.py",
+    "Lib/distutils/tests/test_bdist.py",
+    "Lib/distutils/tests/test_bdist_dumb.py",
+    "Lib/distutils/tests/test_bdist_msi.py",
+    "Lib/distutils/tests/test_bdist_rpm.py",
+    "Lib/distutils/tests/test_bdist_wininst.py",
+    "Lib/distutils/tests/test_build.py",
+    "Lib/distutils/tests/test_build_clib.py",
+    "Lib/distutils/tests/test_build_ext.py",
+    "Lib/distutils/tests/test_build_py.py",
+    "Lib/distutils/tests/test_build_scripts.py",
+    "Lib/distutils/tests/test_check.py",
+    "Lib/distutils/tests/test_clean.py",
+    "Lib/distutils/tests/test_cmd.py",
+    "Lib/distutils/tests/test_config.py",
+    "Lib/distutils/tests/test_config_cmd.py",
+    "Lib/distutils/tests/test_core.py",
+    "Lib/distutils/tests/test_cygwinccompiler.py",
+    "Lib/distutils/tests/test_dep_util.py",
+    "Lib/distutils/tests/test_dir_util.py",
+    "Lib/distutils/tests/test_dist.py",
+    "Lib/distutils/tests/test_extension.py",
+    "Lib/distutils/tests/test_file_util.py",
+    "Lib/distutils/tests/test_filelist.py",
+    "Lib/distutils/tests/test_install.py",
+    "Lib/distutils/tests/test_install_data.py",
+    "Lib/distutils/tests/test_install_headers.py",
+    "Lib/distutils/tests/test_install_lib.py",
+    "Lib/distutils/tests/test_install_scripts.py",
+    "Lib/distutils/tests/test_log.py",
+    "Lib/distutils/tests/test_msvc9compiler.py",
+    "Lib/distutils/tests/test_msvccompiler.py",
+    "Lib/distutils/tests/test_register.py",
+    "Lib/distutils/tests/test_sdist.py",
+    "Lib/distutils/tests/test_spawn.py",
+    "Lib/distutils/tests/test_sysconfig.py",
+    "Lib/distutils/tests/test_text_file.py",
+    "Lib/distutils/tests/test_unixccompiler.py",
+    "Lib/distutils/tests/test_upload.py",
+    "Lib/distutils/tests/test_util.py",
+    "Lib/distutils/tests/test_version.py",
+    "Lib/distutils/tests/test_versionpredicate.py",
+    "Lib/distutils/text_file.py",
+    "Lib/distutils/unixccompiler.py",
+    "Lib/distutils/util.py",
+    "Lib/distutils/version.py",
+    "Lib/distutils/versionpredicate.py",
+    "Lib/doctest.py",
+    "Lib/email/__init__.py",
+    "Lib/email/__pycache__/__init__.cpython-39.pyc",
+    "Lib/email/__pycache__/_encoded_words.cpython-39.pyc",
+    "Lib/email/__pycache__/_header_value_parser.cpython-39.pyc",
+    "Lib/email/__pycache__/_parseaddr.cpython-39.pyc",
+    "Lib/email/__pycache__/_policybase.cpython-39.pyc",
+    "Lib/email/__pycache__/base64mime.cpython-39.pyc",
+    "Lib/email/__pycache__/charset.cpython-39.pyc",
+    "Lib/email/__pycache__/contentmanager.cpython-39.pyc",
+    "Lib/email/__pycache__/encoders.cpython-39.pyc",
+    "Lib/email/__pycache__/errors.cpython-39.pyc",
+    "Lib/email/__pycache__/feedparser.cpython-39.pyc",
+    "Lib/email/__pycache__/generator.cpython-39.pyc",
+    "Lib/email/__pycache__/header.cpython-39.pyc",
+    "Lib/email/__pycache__/headerregistry.cpython-39.pyc",
+    "Lib/email/__pycache__/iterators.cpython-39.pyc",
+    "Lib/email/__pycache__/message.cpython-39.pyc",
+    "Lib/email/__pycache__/parser.cpython-39.pyc",
+    "Lib/email/__pycache__/policy.cpython-39.pyc",
+    "Lib/email/__pycache__/quoprimime.cpython-39.pyc",
+    "Lib/email/__pycache__/utils.cpython-39.pyc",
+    "Lib/email/_encoded_words.py",
+    "Lib/email/_header_value_parser.py",
+    "Lib/email/_parseaddr.py",
+    "Lib/email/_policybase.py",
+    "Lib/email/architecture.rst",
+    "Lib/email/base64mime.py",
+    "Lib/email/charset.py",
+    "Lib/email/contentmanager.py",
+    "Lib/email/encoders.py",
+    "Lib/email/errors.py",
+    "Lib/email/feedparser.py",
+    "Lib/email/generator.py",
+    "Lib/email/header.py",
+    "Lib/email/headerregistry.py",
+    "Lib/email/iterators.py",
+    "Lib/email/message.py",
+    "Lib/email/mime/__init__.py",
+    "Lib/email/mime/__pycache__/__init__.cpython-39.pyc",
+    "Lib/email/mime/__pycache__/application.cpython-39.pyc",
+    "Lib/email/mime/__pycache__/audio.cpython-39.pyc",
+    "Lib/email/mime/__pycache__/base.cpython-39.pyc",
+    "Lib/email/mime/__pycache__/image.cpython-39.pyc",
+    "Lib/email/mime/__pycache__/message.cpython-39.pyc",
+    "Lib/email/mime/__pycache__/multipart.cpython-39.pyc",
+    "Lib/email/mime/__pycache__/nonmultipart.cpython-39.pyc",
+    "Lib/email/mime/__pycache__/text.cpython-39.pyc",
+    "Lib/email/mime/application.py",
+    "Lib/email/mime/audio.py",
+    "Lib/email/mime/base.py",
+    "Lib/email/mime/image.py",
+    "Lib/email/mime/message.py",
+    "Lib/email/mime/multipart.py",
+    "Lib/email/mime/nonmultipart.py",
+    "Lib/email/mime/text.py",
+    "Lib/email/parser.py",
+    "Lib/email/policy.py",
+    "Lib/email/quoprimime.py",
+    "Lib/email/utils.py",
+    "Lib/encodings/__init__.py",
+    "Lib/encodings/__pycache__/__init__.cpython-39.pyc",
+    "Lib/encodings/__pycache__/aliases.cpython-39.pyc",
+    "Lib/encodings/__pycache__/ascii.cpython-39.pyc",
+    "Lib/encodings/__pycache__/base64_codec.cpython-39.pyc",
+    "Lib/encodings/__pycache__/big5.cpython-39.pyc",
+    "Lib/encodings/__pycache__/big5hkscs.cpython-39.pyc",
+    "Lib/encodings/__pycache__/bz2_codec.cpython-39.pyc",
+    "Lib/encodings/__pycache__/charmap.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp037.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1006.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1026.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1125.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1140.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1250.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1251.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1252.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1253.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1254.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1255.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1256.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1257.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp1258.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp273.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp424.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp437.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp500.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp720.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp737.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp775.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp850.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp852.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp855.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp856.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp857.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp858.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp860.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp861.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp862.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp863.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp864.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp865.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp866.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp869.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp874.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp875.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp932.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp949.cpython-39.pyc",
+    "Lib/encodings/__pycache__/cp950.cpython-39.pyc",
+    "Lib/encodings/__pycache__/euc_jis_2004.cpython-39.pyc",
+    "Lib/encodings/__pycache__/euc_jisx0213.cpython-39.pyc",
+    "Lib/encodings/__pycache__/euc_jp.cpython-39.pyc",
+    "Lib/encodings/__pycache__/euc_kr.cpython-39.pyc",
+    "Lib/encodings/__pycache__/gb18030.cpython-39.pyc",
+    "Lib/encodings/__pycache__/gb2312.cpython-39.pyc",
+    "Lib/encodings/__pycache__/gbk.cpython-39.pyc",
+    "Lib/encodings/__pycache__/hex_codec.cpython-39.pyc",
+    "Lib/encodings/__pycache__/hp_roman8.cpython-39.pyc",
+    "Lib/encodings/__pycache__/hz.cpython-39.pyc",
+    "Lib/encodings/__pycache__/idna.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso2022_jp.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso2022_jp_1.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso2022_jp_2.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso2022_jp_2004.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso2022_jp_3.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso2022_jp_ext.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso2022_kr.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_1.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_10.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_11.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_13.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_14.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_15.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_16.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_2.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_3.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_4.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_5.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_6.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_7.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_8.cpython-39.pyc",
+    "Lib/encodings/__pycache__/iso8859_9.cpython-39.pyc",
+    "Lib/encodings/__pycache__/johab.cpython-39.pyc",
+    "Lib/encodings/__pycache__/koi8_r.cpython-39.pyc",
+    "Lib/encodings/__pycache__/koi8_t.cpython-39.pyc",
+    "Lib/encodings/__pycache__/koi8_u.cpython-39.pyc",
+    "Lib/encodings/__pycache__/kz1048.cpython-39.pyc",
+    "Lib/encodings/__pycache__/latin_1.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_arabic.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_croatian.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_cyrillic.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_farsi.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_greek.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_iceland.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_latin2.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_roman.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_romanian.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mac_turkish.cpython-39.pyc",
+    "Lib/encodings/__pycache__/mbcs.cpython-39.pyc",
+    "Lib/encodings/__pycache__/oem.cpython-39.pyc",
+    "Lib/encodings/__pycache__/palmos.cpython-39.pyc",
+    "Lib/encodings/__pycache__/ptcp154.cpython-39.pyc",
+    "Lib/encodings/__pycache__/punycode.cpython-39.pyc",
+    "Lib/encodings/__pycache__/quopri_codec.cpython-39.pyc",
+    "Lib/encodings/__pycache__/raw_unicode_escape.cpython-39.pyc",
+    "Lib/encodings/__pycache__/rot_13.cpython-39.pyc",
+    "Lib/encodings/__pycache__/shift_jis.cpython-39.pyc",
+    "Lib/encodings/__pycache__/shift_jis_2004.cpython-39.pyc",
+    "Lib/encodings/__pycache__/shift_jisx0213.cpython-39.pyc",
+    "Lib/encodings/__pycache__/tis_620.cpython-39.pyc",
+    "Lib/encodings/__pycache__/undefined.cpython-39.pyc",
+    "Lib/encodings/__pycache__/unicode_escape.cpython-39.pyc",
+    "Lib/encodings/__pycache__/utf_16.cpython-39.pyc",
+    "Lib/encodings/__pycache__/utf_16_be.cpython-39.pyc",
+    "Lib/encodings/__pycache__/utf_16_le.cpython-39.pyc",
+    "Lib/encodings/__pycache__/utf_32.cpython-39.pyc",
+    "Lib/encodings/__pycache__/utf_32_be.cpython-39.pyc",
+    "Lib/encodings/__pycache__/utf_32_le.cpython-39.pyc",
+    "Lib/encodings/__pycache__/utf_7.cpython-39.pyc",
+    "Lib/encodings/__pycache__/utf_8.cpython-39.pyc",
+    "Lib/encodings/__pycache__/utf_8_sig.cpython-39.pyc",
+    "Lib/encodings/__pycache__/uu_codec.cpython-39.pyc",
+    "Lib/encodings/__pycache__/zlib_codec.cpython-39.pyc",
+    "Lib/encodings/aliases.py",
+    "Lib/encodings/ascii.py",
+    "Lib/encodings/base64_codec.py",
+    "Lib/encodings/big5.py",
+    "Lib/encodings/big5hkscs.py",
+    "Lib/encodings/bz2_codec.py",
+    "Lib/encodings/charmap.py",
+    "Lib/encodings/cp037.py",
+    "Lib/encodings/cp1006.py",
+    "Lib/encodings/cp1026.py",
+    "Lib/encodings/cp1125.py",
+    "Lib/encodings/cp1140.py",
+    "Lib/encodings/cp1250.py",
+    "Lib/encodings/cp1251.py",
+    "Lib/encodings/cp1252.py",
+    "Lib/encodings/cp1253.py",
+    "Lib/encodings/cp1254.py",
+    "Lib/encodings/cp1255.py",
+    "Lib/encodings/cp1256.py",
+    "Lib/encodings/cp1257.py",
+    "Lib/encodings/cp1258.py",
+    "Lib/encodings/cp273.py",
+    "Lib/encodings/cp424.py",
+    "Lib/encodings/cp437.py",
+    "Lib/encodings/cp500.py",
+    "Lib/encodings/cp720.py",
+    "Lib/encodings/cp737.py",
+    "Lib/encodings/cp775.py",
+    "Lib/encodings/cp850.py",
+    "Lib/encodings/cp852.py",
+    "Lib/encodings/cp855.py",
+    "Lib/encodings/cp856.py",
+    "Lib/encodings/cp857.py",
+    "Lib/encodings/cp858.py",
+    "Lib/encodings/cp860.py",
+    "Lib/encodings/cp861.py",
+    "Lib/encodings/cp862.py",
+    "Lib/encodings/cp863.py",
+    "Lib/encodings/cp864.py",
+    "Lib/encodings/cp865.py",
+    "Lib/encodings/cp866.py",
+    "Lib/encodings/cp869.py",
+    "Lib/encodings/cp874.py",
+    "Lib/encodings/cp875.py",
+    "Lib/encodings/cp932.py",
+    "Lib/encodings/cp949.py",
+    "Lib/encodings/cp950.py",
+    "Lib/encodings/euc_jis_2004.py",
+    "Lib/encodings/euc_jisx0213.py",
+    "Lib/encodings/euc_jp.py",
+    "Lib/encodings/euc_kr.py",
+    "Lib/encodings/gb18030.py",
+    "Lib/encodings/gb2312.py",
+    "Lib/encodings/gbk.py",
+    "Lib/encodings/hex_codec.py",
+    "Lib/encodings/hp_roman8.py",
+    "Lib/encodings/hz.py",
+    "Lib/encodings/idna.py",
+    "Lib/encodings/iso2022_jp.py",
+    "Lib/encodings/iso2022_jp_1.py",
+    "Lib/encodings/iso2022_jp_2.py",
+    "Lib/encodings/iso2022_jp_2004.py",
+    "Lib/encodings/iso2022_jp_3.py",
+    "Lib/encodings/iso2022_jp_ext.py",
+    "Lib/encodings/iso2022_kr.py",
+    "Lib/encodings/iso8859_1.py",
+    "Lib/encodings/iso8859_10.py",
+    "Lib/encodings/iso8859_11.py",
+    "Lib/encodings/iso8859_13.py",
+    "Lib/encodings/iso8859_14.py",
+    "Lib/encodings/iso8859_15.py",
+    "Lib/encodings/iso8859_16.py",
+    "Lib/encodings/iso8859_2.py",
+    "Lib/encodings/iso8859_3.py",
+    "Lib/encodings/iso8859_4.py",
+    "Lib/encodings/iso8859_5.py",
+    "Lib/encodings/iso8859_6.py",
+    "Lib/encodings/iso8859_7.py",
+    "Lib/encodings/iso8859_8.py",
+    "Lib/encodings/iso8859_9.py",
+    "Lib/encodings/johab.py",
+    "Lib/encodings/koi8_r.py",
+    "Lib/encodings/koi8_t.py",
+    "Lib/encodings/koi8_u.py",
+    "Lib/encodings/kz1048.py",
+    "Lib/encodings/latin_1.py",
+    "Lib/encodings/mac_arabic.py",
+    "Lib/encodings/mac_croatian.py",
+    "Lib/encodings/mac_cyrillic.py",
+    "Lib/encodings/mac_farsi.py",
+    "Lib/encodings/mac_greek.py",
+    "Lib/encodings/mac_iceland.py",
+    "Lib/encodings/mac_latin2.py",
+    "Lib/encodings/mac_roman.py",
+    "Lib/encodings/mac_romanian.py",
+    "Lib/encodings/mac_turkish.py",
+    "Lib/encodings/mbcs.py",
+    "Lib/encodings/oem.py",
+    "Lib/encodings/palmos.py",
+    "Lib/encodings/ptcp154.py",
+    "Lib/encodings/punycode.py",
+    "Lib/encodings/quopri_codec.py",
+    "Lib/encodings/raw_unicode_escape.py",
+    "Lib/encodings/rot_13.py",
+    "Lib/encodings/shift_jis.py",
+    "Lib/encodings/shift_jis_2004.py",
+    "Lib/encodings/shift_jisx0213.py",
+    "Lib/encodings/tis_620.py",
+    "Lib/encodings/undefined.py",
+    "Lib/encodings/unicode_escape.py",
+    "Lib/encodings/utf_16.py",
+    "Lib/encodings/utf_16_be.py",
+    "Lib/encodings/utf_16_le.py",
+    "Lib/encodings/utf_32.py",
+    "Lib/encodings/utf_32_be.py",
+    "Lib/encodings/utf_32_le.py",
+    "Lib/encodings/utf_7.py",
+    "Lib/encodings/utf_8.py",
+    "Lib/encodings/utf_8_sig.py",
+    "Lib/encodings/uu_codec.py",
+    "Lib/encodings/zlib_codec.py",
+    "Lib/ensurepip/__init__.py",
+    "Lib/ensurepip/__main__.py",
+    "Lib/ensurepip/__pycache__/__init__.cpython-39.pyc",
+    "Lib/ensurepip/__pycache__/__main__.cpython-39.pyc",
+    "Lib/ensurepip/__pycache__/_uninstall.cpython-39.pyc",
+    "Lib/ensurepip/_bundled/__init__.py",
+    "Lib/ensurepip/_bundled/__pycache__/__init__.cpython-39.pyc",
+    "Lib/ensurepip/_bundled/pip-23.0.1-py3-none-any.whl",
+    "Lib/ensurepip/_bundled/setuptools-58.1.0-py3-none-any.whl",
+    "Lib/ensurepip/_uninstall.py",
+    "Lib/enum.py",
+    "Lib/filecmp.py",
+    "Lib/fileinput.py",
+    "Lib/fnmatch.py",
+    "Lib/formatter.py",
+    "Lib/fractions.py",
+    "Lib/ftplib.py",
+    "Lib/functools.py",
+    "Lib/genericpath.py",
+    "Lib/getopt.py",
+    "Lib/getpass.py",
+    "Lib/gettext.py",
+    "Lib/glob.py",
+    "Lib/graphlib.py",
+    "Lib/gzip.py",
+    "Lib/hashlib.py",
+    "Lib/heapq.py",
+    "Lib/hmac.py",
+    "Lib/html/__init__.py",
+    "Lib/html/__pycache__/__init__.cpython-39.pyc",
+    "Lib/html/__pycache__/entities.cpython-39.pyc",
+    "Lib/html/__pycache__/parser.cpython-39.pyc",
+    "Lib/html/entities.py",
+    "Lib/html/parser.py",
+    "Lib/http/__init__.py",
+    "Lib/http/__pycache__/__init__.cpython-39.pyc",
+    "Lib/http/__pycache__/client.cpython-39.pyc",
+    "Lib/http/__pycache__/cookiejar.cpython-39.pyc",
+    "Lib/http/__pycache__/cookies.cpython-39.pyc",
+    "Lib/http/__pycache__/server.cpython-39.pyc",
+    "Lib/http/client.py",
+    "Lib/http/cookiejar.py",
+    "Lib/http/cookies.py",
+    "Lib/http/server.py",
+    "Lib/idlelib/CREDITS.txt",
+    "Lib/idlelib/ChangeLog",
+    "Lib/idlelib/HISTORY.txt",
+    "Lib/idlelib/Icons/README.txt",
+    "Lib/idlelib/Icons/folder.gif",
+    "Lib/idlelib/Icons/idle.ico",
+    "Lib/idlelib/Icons/idle_16.gif",
+    "Lib/idlelib/Icons/idle_16.png",
+    "Lib/idlelib/Icons/idle_256.png",
+    "Lib/idlelib/Icons/idle_32.gif",
+    "Lib/idlelib/Icons/idle_32.png",
+    "Lib/idlelib/Icons/idle_48.gif",
+    "Lib/idlelib/Icons/idle_48.png",
+    "Lib/idlelib/Icons/minusnode.gif",
+    "Lib/idlelib/Icons/openfolder.gif",
+    "Lib/idlelib/Icons/plusnode.gif",
+    "Lib/idlelib/Icons/python.gif",
+    "Lib/idlelib/Icons/tk.gif",
+    "Lib/idlelib/NEWS.txt",
+    "Lib/idlelib/NEWS2x.txt",
+    "Lib/idlelib/README.txt",
+    "Lib/idlelib/TODO.txt",
+    "Lib/idlelib/__init__.py",
+    "Lib/idlelib/__main__.py",
+    "Lib/idlelib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/__main__.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/autocomplete.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/autocomplete_w.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/autoexpand.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/browser.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/calltip.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/calltip_w.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/codecontext.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/colorizer.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/config.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/config_key.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/configdialog.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/debugger.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/debugger_r.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/debugobj.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/debugobj_r.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/delegator.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/dynoption.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/editor.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/filelist.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/format.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/grep.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/help.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/help_about.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/history.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/hyperparser.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/idle.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/iomenu.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/macosx.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/mainmenu.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/multicall.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/outwin.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/parenmatch.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/pathbrowser.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/percolator.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/pyparse.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/pyshell.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/query.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/redirector.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/replace.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/rpc.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/run.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/runscript.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/scrolledlist.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/search.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/searchbase.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/searchengine.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/sidebar.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/squeezer.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/stackviewer.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/statusbar.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/textview.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/tooltip.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/tree.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/undo.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/util.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/window.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/zoomheight.cpython-39.pyc",
+    "Lib/idlelib/__pycache__/zzdummy.cpython-39.pyc",
+    "Lib/idlelib/autocomplete.py",
+    "Lib/idlelib/autocomplete_w.py",
+    "Lib/idlelib/autoexpand.py",
+    "Lib/idlelib/browser.py",
+    "Lib/idlelib/calltip.py",
+    "Lib/idlelib/calltip_w.py",
+    "Lib/idlelib/codecontext.py",
+    "Lib/idlelib/colorizer.py",
+    "Lib/idlelib/config-extensions.def",
+    "Lib/idlelib/config-highlight.def",
+    "Lib/idlelib/config-keys.def",
+    "Lib/idlelib/config-main.def",
+    "Lib/idlelib/config.py",
+    "Lib/idlelib/config_key.py",
+    "Lib/idlelib/configdialog.py",
+    "Lib/idlelib/debugger.py",
+    "Lib/idlelib/debugger_r.py",
+    "Lib/idlelib/debugobj.py",
+    "Lib/idlelib/debugobj_r.py",
+    "Lib/idlelib/delegator.py",
+    "Lib/idlelib/dynoption.py",
+    "Lib/idlelib/editor.py",
+    "Lib/idlelib/extend.txt",
+    "Lib/idlelib/filelist.py",
+    "Lib/idlelib/format.py",
+    "Lib/idlelib/grep.py",
+    "Lib/idlelib/help.html",
+    "Lib/idlelib/help.py",
+    "Lib/idlelib/help_about.py",
+    "Lib/idlelib/history.py",
+    "Lib/idlelib/hyperparser.py",
+    "Lib/idlelib/idle.bat",
+    "Lib/idlelib/idle.py",
+    "Lib/idlelib/idle.pyw",
+    "Lib/idlelib/idle_test/README.txt",
+    "Lib/idlelib/idle_test/__init__.py",
+    "Lib/idlelib/idle_test/__pycache__/__init__.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/htest.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/mock_idle.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/mock_tk.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/template.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_autocomplete.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_autoexpand.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_browser.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_calltip.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_calltip_w.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_codecontext.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_colorizer.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_config.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_config_key.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_configdialog.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_debugger.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_debugger_r.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_debugobj.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_delegator.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_editmenu.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_editor.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_filelist.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_format.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_grep.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_help.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_help_about.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_history.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_hyperparser.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_iomenu.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_macosx.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_mainmenu.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_multicall.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_outwin.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_parenmatch.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_percolator.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_pyparse.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_pyshell.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_query.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_redirector.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_replace.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_rpc.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_run.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_runscript.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_search.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_searchbase.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_searchengine.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_sidebar.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_squeezer.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_stackviewer.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_statusbar.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_text.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_textview.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_tooltip.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_tree.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_undo.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_util.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_warning.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_window.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_zoomheight.cpython-39.pyc",
+    "Lib/idlelib/idle_test/__pycache__/test_zzdummy.cpython-39.pyc",
+    "Lib/idlelib/idle_test/example_noext",
+    "Lib/idlelib/idle_test/example_stub.pyi",
+    "Lib/idlelib/idle_test/htest.py",
+    "Lib/idlelib/idle_test/mock_idle.py",
+    "Lib/idlelib/idle_test/mock_tk.py",
+    "Lib/idlelib/idle_test/template.py",
+    "Lib/idlelib/idle_test/test_autocomplete.py",
+    "Lib/idlelib/idle_test/test_autocomplete_w.py",
+    "Lib/idlelib/idle_test/test_autoexpand.py",
+    "Lib/idlelib/idle_test/test_browser.py",
+    "Lib/idlelib/idle_test/test_calltip.py",
+    "Lib/idlelib/idle_test/test_calltip_w.py",
+    "Lib/idlelib/idle_test/test_codecontext.py",
+    "Lib/idlelib/idle_test/test_colorizer.py",
+    "Lib/idlelib/idle_test/test_config.py",
+    "Lib/idlelib/idle_test/test_config_key.py",
+    "Lib/idlelib/idle_test/test_configdialog.py",
+    "Lib/idlelib/idle_test/test_debugger.py",
+    "Lib/idlelib/idle_test/test_debugger_r.py",
+    "Lib/idlelib/idle_test/test_debugobj.py",
+    "Lib/idlelib/idle_test/test_debugobj_r.py",
+    "Lib/idlelib/idle_test/test_delegator.py",
+    "Lib/idlelib/idle_test/test_editmenu.py",
+    "Lib/idlelib/idle_test/test_editor.py",
+    "Lib/idlelib/idle_test/test_filelist.py",
+    "Lib/idlelib/idle_test/test_format.py",
+    "Lib/idlelib/idle_test/test_grep.py",
+    "Lib/idlelib/idle_test/test_help.py",
+    "Lib/idlelib/idle_test/test_help_about.py",
+    "Lib/idlelib/idle_test/test_history.py",
+    "Lib/idlelib/idle_test/test_hyperparser.py",
+    "Lib/idlelib/idle_test/test_iomenu.py",
+    "Lib/idlelib/idle_test/test_macosx.py",
+    "Lib/idlelib/idle_test/test_mainmenu.py",
+    "Lib/idlelib/idle_test/test_multicall.py",
+    "Lib/idlelib/idle_test/test_outwin.py",
+    "Lib/idlelib/idle_test/test_parenmatch.py",
+    "Lib/idlelib/idle_test/test_pathbrowser.py",
+    "Lib/idlelib/idle_test/test_percolator.py",
+    "Lib/idlelib/idle_test/test_pyparse.py",
+    "Lib/idlelib/idle_test/test_pyshell.py",
+    "Lib/idlelib/idle_test/test_query.py",
+    "Lib/idlelib/idle_test/test_redirector.py",
+    "Lib/idlelib/idle_test/test_replace.py",
+    "Lib/idlelib/idle_test/test_rpc.py",
+    "Lib/idlelib/idle_test/test_run.py",
+    "Lib/idlelib/idle_test/test_runscript.py",
+    "Lib/idlelib/idle_test/test_scrolledlist.py",
+    "Lib/idlelib/idle_test/test_search.py",
+    "Lib/idlelib/idle_test/test_searchbase.py",
+    "Lib/idlelib/idle_test/test_searchengine.py",
+    "Lib/idlelib/idle_test/test_sidebar.py",
+    "Lib/idlelib/idle_test/test_squeezer.py",
+    "Lib/idlelib/idle_test/test_stackviewer.py",
+    "Lib/idlelib/idle_test/test_statusbar.py",
+    "Lib/idlelib/idle_test/test_text.py",
+    "Lib/idlelib/idle_test/test_textview.py",
+    "Lib/idlelib/idle_test/test_tooltip.py",
+    "Lib/idlelib/idle_test/test_tree.py",
+    "Lib/idlelib/idle_test/test_undo.py",
+    "Lib/idlelib/idle_test/test_util.py",
+    "Lib/idlelib/idle_test/test_warning.py",
+    "Lib/idlelib/idle_test/test_window.py",
+    "Lib/idlelib/idle_test/test_zoomheight.py",
+    "Lib/idlelib/idle_test/test_zzdummy.py",
+    "Lib/idlelib/iomenu.py",
+    "Lib/idlelib/macosx.py",
+    "Lib/idlelib/mainmenu.py",
+    "Lib/idlelib/multicall.py",
+    "Lib/idlelib/outwin.py",
+    "Lib/idlelib/parenmatch.py",
+    "Lib/idlelib/pathbrowser.py",
+    "Lib/idlelib/percolator.py",
+    "Lib/idlelib/pyparse.py",
+    "Lib/idlelib/pyshell.py",
+    "Lib/idlelib/query.py",
+    "Lib/idlelib/redirector.py",
+    "Lib/idlelib/replace.py",
+    "Lib/idlelib/rpc.py",
+    "Lib/idlelib/run.py",
+    "Lib/idlelib/runscript.py",
+    "Lib/idlelib/scrolledlist.py",
+    "Lib/idlelib/search.py",
+    "Lib/idlelib/searchbase.py",
+    "Lib/idlelib/searchengine.py",
+    "Lib/idlelib/sidebar.py",
+    "Lib/idlelib/squeezer.py",
+    "Lib/idlelib/stackviewer.py",
+    "Lib/idlelib/statusbar.py",
+    "Lib/idlelib/textview.py",
+    "Lib/idlelib/tooltip.py",
+    "Lib/idlelib/tree.py",
+    "Lib/idlelib/undo.py",
+    "Lib/idlelib/util.py",
+    "Lib/idlelib/window.py",
+    "Lib/idlelib/zoomheight.py",
+    "Lib/idlelib/zzdummy.py",
+    "Lib/imaplib.py",
+    "Lib/imghdr.py",
+    "Lib/imp.py",
+    "Lib/importlib/__init__.py",
+    "Lib/importlib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/importlib/__pycache__/_bootstrap.cpython-39.pyc",
+    "Lib/importlib/__pycache__/_bootstrap_external.cpython-39.pyc",
+    "Lib/importlib/__pycache__/_common.cpython-39.pyc",
+    "Lib/importlib/__pycache__/abc.cpython-39.pyc",
+    "Lib/importlib/__pycache__/machinery.cpython-39.pyc",
+    "Lib/importlib/__pycache__/metadata.cpython-39.pyc",
+    "Lib/importlib/__pycache__/resources.cpython-39.pyc",
+    "Lib/importlib/__pycache__/util.cpython-39.pyc",
+    "Lib/importlib/_bootstrap.py",
+    "Lib/importlib/_bootstrap_external.py",
+    "Lib/importlib/_common.py",
+    "Lib/importlib/abc.py",
+    "Lib/importlib/machinery.py",
+    "Lib/importlib/metadata.py",
+    "Lib/importlib/resources.py",
+    "Lib/importlib/util.py",
+    "Lib/inspect.py",
+    "Lib/io.py",
+    "Lib/ipaddress.py",
+    "Lib/json/__init__.py",
+    "Lib/json/__pycache__/__init__.cpython-39.pyc",
+    "Lib/json/__pycache__/decoder.cpython-39.pyc",
+    "Lib/json/__pycache__/encoder.cpython-39.pyc",
+    "Lib/json/__pycache__/scanner.cpython-39.pyc",
+    "Lib/json/__pycache__/tool.cpython-39.pyc",
+    "Lib/json/decoder.py",
+    "Lib/json/encoder.py",
+    "Lib/json/scanner.py",
+    "Lib/json/tool.py",
+    "Lib/keyword.py",
+    "Lib/lib2to3/Grammar.txt",
+    "Lib/lib2to3/Grammar3.9.21.final.0.pickle",
+    "Lib/lib2to3/PatternGrammar.txt",
+    "Lib/lib2to3/PatternGrammar3.9.21.final.0.pickle",
+    "Lib/lib2to3/__init__.py",
+    "Lib/lib2to3/__main__.py",
+    "Lib/lib2to3/__pycache__/__init__.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/__main__.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/btm_matcher.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/btm_utils.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/fixer_base.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/fixer_util.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/main.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/patcomp.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/pygram.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/pytree.cpython-39.pyc",
+    "Lib/lib2to3/__pycache__/refactor.cpython-39.pyc",
+    "Lib/lib2to3/btm_matcher.py",
+    "Lib/lib2to3/btm_utils.py",
+    "Lib/lib2to3/fixer_base.py",
+    "Lib/lib2to3/fixer_util.py",
+    "Lib/lib2to3/fixes/__init__.py",
+    "Lib/lib2to3/fixes/__pycache__/__init__.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_apply.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_asserts.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_basestring.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_buffer.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_dict.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_except.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_exec.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_execfile.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_filter.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_future.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_has_key.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_idioms.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_import.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_imports.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_imports2.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_input.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_intern.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_isinstance.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_itertools.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_long.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_map.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_metaclass.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_ne.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_next.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_nonzero.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_numliterals.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_operator.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_paren.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_print.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_raise.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_raw_input.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_reduce.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_reload.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_renames.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_repr.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_set_literal.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_standarderror.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_throw.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_types.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_unicode.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_urllib.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_xrange.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-39.pyc",
+    "Lib/lib2to3/fixes/__pycache__/fix_zip.cpython-39.pyc",
+    "Lib/lib2to3/fixes/fix_apply.py",
+    "Lib/lib2to3/fixes/fix_asserts.py",
+    "Lib/lib2to3/fixes/fix_basestring.py",
+    "Lib/lib2to3/fixes/fix_buffer.py",
+    "Lib/lib2to3/fixes/fix_dict.py",
+    "Lib/lib2to3/fixes/fix_except.py",
+    "Lib/lib2to3/fixes/fix_exec.py",
+    "Lib/lib2to3/fixes/fix_execfile.py",
+    "Lib/lib2to3/fixes/fix_exitfunc.py",
+    "Lib/lib2to3/fixes/fix_filter.py",
+    "Lib/lib2to3/fixes/fix_funcattrs.py",
+    "Lib/lib2to3/fixes/fix_future.py",
+    "Lib/lib2to3/fixes/fix_getcwdu.py",
+    "Lib/lib2to3/fixes/fix_has_key.py",
+    "Lib/lib2to3/fixes/fix_idioms.py",
+    "Lib/lib2to3/fixes/fix_import.py",
+    "Lib/lib2to3/fixes/fix_imports.py",
+    "Lib/lib2to3/fixes/fix_imports2.py",
+    "Lib/lib2to3/fixes/fix_input.py",
+    "Lib/lib2to3/fixes/fix_intern.py",
+    "Lib/lib2to3/fixes/fix_isinstance.py",
+    "Lib/lib2to3/fixes/fix_itertools.py",
+    "Lib/lib2to3/fixes/fix_itertools_imports.py",
+    "Lib/lib2to3/fixes/fix_long.py",
+    "Lib/lib2to3/fixes/fix_map.py",
+    "Lib/lib2to3/fixes/fix_metaclass.py",
+    "Lib/lib2to3/fixes/fix_methodattrs.py",
+    "Lib/lib2to3/fixes/fix_ne.py",
+    "Lib/lib2to3/fixes/fix_next.py",
+    "Lib/lib2to3/fixes/fix_nonzero.py",
+    "Lib/lib2to3/fixes/fix_numliterals.py",
+    "Lib/lib2to3/fixes/fix_operator.py",
+    "Lib/lib2to3/fixes/fix_paren.py",
+    "Lib/lib2to3/fixes/fix_print.py",
+    "Lib/lib2to3/fixes/fix_raise.py",
+    "Lib/lib2to3/fixes/fix_raw_input.py",
+    "Lib/lib2to3/fixes/fix_reduce.py",
+    "Lib/lib2to3/fixes/fix_reload.py",
+    "Lib/lib2to3/fixes/fix_renames.py",
+    "Lib/lib2to3/fixes/fix_repr.py",
+    "Lib/lib2to3/fixes/fix_set_literal.py",
+    "Lib/lib2to3/fixes/fix_standarderror.py",
+    "Lib/lib2to3/fixes/fix_sys_exc.py",
+    "Lib/lib2to3/fixes/fix_throw.py",
+    "Lib/lib2to3/fixes/fix_tuple_params.py",
+    "Lib/lib2to3/fixes/fix_types.py",
+    "Lib/lib2to3/fixes/fix_unicode.py",
+    "Lib/lib2to3/fixes/fix_urllib.py",
+    "Lib/lib2to3/fixes/fix_ws_comma.py",
+    "Lib/lib2to3/fixes/fix_xrange.py",
+    "Lib/lib2to3/fixes/fix_xreadlines.py",
+    "Lib/lib2to3/fixes/fix_zip.py",
+    "Lib/lib2to3/main.py",
+    "Lib/lib2to3/patcomp.py",
+    "Lib/lib2to3/pgen2/__init__.py",
+    "Lib/lib2to3/pgen2/__pycache__/__init__.cpython-39.pyc",
+    "Lib/lib2to3/pgen2/__pycache__/conv.cpython-39.pyc",
+    "Lib/lib2to3/pgen2/__pycache__/driver.cpython-39.pyc",
+    "Lib/lib2to3/pgen2/__pycache__/grammar.cpython-39.pyc",
+    "Lib/lib2to3/pgen2/__pycache__/literals.cpython-39.pyc",
+    "Lib/lib2to3/pgen2/__pycache__/parse.cpython-39.pyc",
+    "Lib/lib2to3/pgen2/__pycache__/pgen.cpython-39.pyc",
+    "Lib/lib2to3/pgen2/__pycache__/token.cpython-39.pyc",
+    "Lib/lib2to3/pgen2/__pycache__/tokenize.cpython-39.pyc",
+    "Lib/lib2to3/pgen2/conv.py",
+    "Lib/lib2to3/pgen2/driver.py",
+    "Lib/lib2to3/pgen2/grammar.py",
+    "Lib/lib2to3/pgen2/literals.py",
+    "Lib/lib2to3/pgen2/parse.py",
+    "Lib/lib2to3/pgen2/pgen.py",
+    "Lib/lib2to3/pgen2/token.py",
+    "Lib/lib2to3/pgen2/tokenize.py",
+    "Lib/lib2to3/pygram.py",
+    "Lib/lib2to3/pytree.py",
+    "Lib/lib2to3/refactor.py",
+    "Lib/linecache.py",
+    "Lib/locale.py",
+    "Lib/logging/__init__.py",
+    "Lib/logging/__pycache__/__init__.cpython-39.pyc",
+    "Lib/logging/__pycache__/config.cpython-39.pyc",
+    "Lib/logging/__pycache__/handlers.cpython-39.pyc",
+    "Lib/logging/config.py",
+    "Lib/logging/handlers.py",
+    "Lib/lzma.py",
+    "Lib/mailbox.py",
+    "Lib/mailcap.py",
+    "Lib/mimetypes.py",
+    "Lib/modulefinder.py",
+    "Lib/msilib/__init__.py",
+    "Lib/msilib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/msilib/__pycache__/schema.cpython-39.pyc",
+    "Lib/msilib/__pycache__/sequence.cpython-39.pyc",
+    "Lib/msilib/__pycache__/text.cpython-39.pyc",
+    "Lib/msilib/schema.py",
+    "Lib/msilib/sequence.py",
+    "Lib/msilib/text.py",
+    "Lib/multiprocessing/__init__.py",
+    "Lib/multiprocessing/__pycache__/__init__.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/connection.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/context.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/forkserver.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/heap.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/managers.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/pool.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/popen_fork.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/popen_forkserver.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/popen_spawn_posix.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/popen_spawn_win32.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/process.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/queues.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/reduction.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/resource_sharer.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/resource_tracker.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/shared_memory.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/sharedctypes.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/spawn.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/synchronize.cpython-39.pyc",
+    "Lib/multiprocessing/__pycache__/util.cpython-39.pyc",
+    "Lib/multiprocessing/connection.py",
+    "Lib/multiprocessing/context.py",
+    "Lib/multiprocessing/dummy/__init__.py",
+    "Lib/multiprocessing/dummy/__pycache__/__init__.cpython-39.pyc",
+    "Lib/multiprocessing/dummy/__pycache__/connection.cpython-39.pyc",
+    "Lib/multiprocessing/dummy/connection.py",
+    "Lib/multiprocessing/forkserver.py",
+    "Lib/multiprocessing/heap.py",
+    "Lib/multiprocessing/managers.py",
+    "Lib/multiprocessing/pool.py",
+    "Lib/multiprocessing/popen_fork.py",
+    "Lib/multiprocessing/popen_forkserver.py",
+    "Lib/multiprocessing/popen_spawn_posix.py",
+    "Lib/multiprocessing/popen_spawn_win32.py",
+    "Lib/multiprocessing/process.py",
+    "Lib/multiprocessing/queues.py",
+    "Lib/multiprocessing/reduction.py",
+    "Lib/multiprocessing/resource_sharer.py",
+    "Lib/multiprocessing/resource_tracker.py",
+    "Lib/multiprocessing/shared_memory.py",
+    "Lib/multiprocessing/sharedctypes.py",
+    "Lib/multiprocessing/spawn.py",
+    "Lib/multiprocessing/synchronize.py",
+    "Lib/multiprocessing/util.py",
+    "Lib/netrc.py",
+    "Lib/nntplib.py",
+    "Lib/ntpath.py",
+    "Lib/nturl2path.py",
+    "Lib/numbers.py",
+    "Lib/opcode.py",
+    "Lib/operator.py",
+    "Lib/optparse.py",
+    "Lib/os.py",
+    "Lib/pathlib.py",
+    "Lib/pdb.py",
+    "Lib/pickle.py",
+    "Lib/pickletools.py",
+    "Lib/pipes.py",
+    "Lib/pkgutil.py",
+    "Lib/platform.py",
+    "Lib/plistlib.py",
+    "Lib/poplib.py",
+    "Lib/posixpath.py",
+    "Lib/pprint.py",
+    "Lib/profile.py",
+    "Lib/pstats.py",
+    "Lib/pty.py",
+    "Lib/py_compile.py",
+    "Lib/pyclbr.py",
+    "Lib/pydoc.py",
+    "Lib/pydoc_data/__init__.py",
+    "Lib/pydoc_data/__pycache__/__init__.cpython-39.pyc",
+    "Lib/pydoc_data/__pycache__/topics.cpython-39.pyc",
+    "Lib/pydoc_data/_pydoc.css",
+    "Lib/pydoc_data/topics.py",
+    "Lib/queue.py",
+    "Lib/quopri.py",
+    "Lib/random.py",
+    "Lib/re.py",
+    "Lib/reprlib.py",
+    "Lib/rlcompleter.py",
+    "Lib/runpy.py",
+    "Lib/sched.py",
+    "Lib/secrets.py",
+    "Lib/selectors.py",
+    "Lib/shelve.py",
+    "Lib/shlex.py",
+    "Lib/shutil.py",
+    "Lib/signal.py",
+    "Lib/site-packages/README.txt",
+    "Lib/site.py",
+    "Lib/smtpd.py",
+    "Lib/smtplib.py",
+    "Lib/sndhdr.py",
+    "Lib/socket.py",
+    "Lib/socketserver.py",
+    "Lib/sqlite3/__init__.py",
+    "Lib/sqlite3/__pycache__/__init__.cpython-39.pyc",
+    "Lib/sqlite3/__pycache__/dbapi2.cpython-39.pyc",
+    "Lib/sqlite3/__pycache__/dump.cpython-39.pyc",
+    "Lib/sqlite3/dbapi2.py",
+    "Lib/sqlite3/dump.py",
+    "Lib/sqlite3/test/__init__.py",
+    "Lib/sqlite3/test/__pycache__/__init__.cpython-39.pyc",
+    "Lib/sqlite3/test/__pycache__/backup.cpython-39.pyc",
+    "Lib/sqlite3/test/__pycache__/dbapi.cpython-39.pyc",
+    "Lib/sqlite3/test/__pycache__/dump.cpython-39.pyc",
+    "Lib/sqlite3/test/__pycache__/factory.cpython-39.pyc",
+    "Lib/sqlite3/test/__pycache__/hooks.cpython-39.pyc",
+    "Lib/sqlite3/test/__pycache__/regression.cpython-39.pyc",
+    "Lib/sqlite3/test/__pycache__/transactions.cpython-39.pyc",
+    "Lib/sqlite3/test/__pycache__/types.cpython-39.pyc",
+    "Lib/sqlite3/test/__pycache__/userfunctions.cpython-39.pyc",
+    "Lib/sqlite3/test/backup.py",
+    "Lib/sqlite3/test/dbapi.py",
+    "Lib/sqlite3/test/dump.py",
+    "Lib/sqlite3/test/factory.py",
+    "Lib/sqlite3/test/hooks.py",
+    "Lib/sqlite3/test/regression.py",
+    "Lib/sqlite3/test/transactions.py",
+    "Lib/sqlite3/test/types.py",
+    "Lib/sqlite3/test/userfunctions.py",
+    "Lib/sre_compile.py",
+    "Lib/sre_constants.py",
+    "Lib/sre_parse.py",
+    "Lib/ssl.py",
+    "Lib/stat.py",
+    "Lib/statistics.py",
+    "Lib/string.py",
+    "Lib/stringprep.py",
+    "Lib/struct.py",
+    "Lib/subprocess.py",
+    "Lib/sunau.py",
+    "Lib/symbol.py",
+    "Lib/symtable.py",
+    "Lib/sysconfig.py",
+    "Lib/tabnanny.py",
+    "Lib/tarfile.py",
+    "Lib/telnetlib.py",
+    "Lib/tempfile.py",
+    "Lib/test/__init__.py",
+    "Lib/test/__pycache__/__init__.cpython-39.pyc",
+    "Lib/test/support/__init__.py",
+    "Lib/test/support/__pycache__/__init__.cpython-39.pyc",
+    "Lib/test/support/__pycache__/bytecode_helper.cpython-39.pyc",
+    "Lib/test/support/__pycache__/hashlib_helper.cpython-39.pyc",
+    "Lib/test/support/__pycache__/logging_helper.cpython-39.pyc",
+    "Lib/test/support/__pycache__/script_helper.cpython-39.pyc",
+    "Lib/test/support/__pycache__/socket_helper.cpython-39.pyc",
+    "Lib/test/support/__pycache__/testresult.cpython-39.pyc",
+    "Lib/test/support/__pycache__/warnings_helper.cpython-39.pyc",
+    "Lib/test/support/bytecode_helper.py",
+    "Lib/test/support/hashlib_helper.py",
+    "Lib/test/support/logging_helper.py",
+    "Lib/test/support/script_helper.py",
+    "Lib/test/support/socket_helper.py",
+    "Lib/test/support/testresult.py",
+    "Lib/test/support/warnings_helper.py",
+    "Lib/textwrap.py",
+    "Lib/this.py",
+    "Lib/threading.py",
+    "Lib/timeit.py",
+    "Lib/tkinter/__init__.py",
+    "Lib/tkinter/__main__.py",
+    "Lib/tkinter/__pycache__/__init__.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/__main__.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/colorchooser.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/commondialog.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/constants.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/dialog.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/dnd.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/filedialog.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/font.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/messagebox.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/scrolledtext.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/simpledialog.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/tix.cpython-39.pyc",
+    "Lib/tkinter/__pycache__/ttk.cpython-39.pyc",
+    "Lib/tkinter/colorchooser.py",
+    "Lib/tkinter/commondialog.py",
+    "Lib/tkinter/constants.py",
+    "Lib/tkinter/dialog.py",
+    "Lib/tkinter/dnd.py",
+    "Lib/tkinter/filedialog.py",
+    "Lib/tkinter/font.py",
+    "Lib/tkinter/messagebox.py",
+    "Lib/tkinter/scrolledtext.py",
+    "Lib/tkinter/simpledialog.py",
+    "Lib/tkinter/test/README",
+    "Lib/tkinter/test/__init__.py",
+    "Lib/tkinter/test/__pycache__/__init__.cpython-39.pyc",
+    "Lib/tkinter/test/__pycache__/support.cpython-39.pyc",
+    "Lib/tkinter/test/__pycache__/widget_tests.cpython-39.pyc",
+    "Lib/tkinter/test/support.py",
+    "Lib/tkinter/test/test_tkinter/__init__.py",
+    "Lib/tkinter/test/test_tkinter/__pycache__/__init__.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_colorchooser.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_font.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_geometry_managers.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_images.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_loadtk.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_misc.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_simpledialog.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_text.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_variables.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/__pycache__/test_widgets.cpython-39.pyc",
+    "Lib/tkinter/test/test_tkinter/test_colorchooser.py",
+    "Lib/tkinter/test/test_tkinter/test_font.py",
+    "Lib/tkinter/test/test_tkinter/test_geometry_managers.py",
+    "Lib/tkinter/test/test_tkinter/test_images.py",
+    "Lib/tkinter/test/test_tkinter/test_loadtk.py",
+    "Lib/tkinter/test/test_tkinter/test_misc.py",
+    "Lib/tkinter/test/test_tkinter/test_simpledialog.py",
+    "Lib/tkinter/test/test_tkinter/test_text.py",
+    "Lib/tkinter/test/test_tkinter/test_variables.py",
+    "Lib/tkinter/test/test_tkinter/test_widgets.py",
+    "Lib/tkinter/test/test_ttk/__init__.py",
+    "Lib/tkinter/test/test_ttk/__pycache__/__init__.cpython-39.pyc",
+    "Lib/tkinter/test/test_ttk/__pycache__/test_extensions.cpython-39.pyc",
+    "Lib/tkinter/test/test_ttk/__pycache__/test_style.cpython-39.pyc",
+    "Lib/tkinter/test/test_ttk/__pycache__/test_widgets.cpython-39.pyc",
+    "Lib/tkinter/test/test_ttk/test_extensions.py",
+    "Lib/tkinter/test/test_ttk/test_style.py",
+    "Lib/tkinter/test/test_ttk/test_widgets.py",
+    "Lib/tkinter/test/widget_tests.py",
+    "Lib/tkinter/tix.py",
+    "Lib/tkinter/ttk.py",
+    "Lib/token.py",
+    "Lib/tokenize.py",
+    "Lib/trace.py",
+    "Lib/traceback.py",
+    "Lib/tracemalloc.py",
+    "Lib/tty.py",
+    "Lib/turtle.py",
+    "Lib/turtledemo/__init__.py",
+    "Lib/turtledemo/__main__.py",
+    "Lib/turtledemo/__pycache__/__init__.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/__main__.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/bytedesign.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/chaos.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/clock.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/colormixer.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/forest.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/fractalcurves.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/lindenmayer.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/minimal_hanoi.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/nim.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/paint.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/peace.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/penrose.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/planet_and_moon.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/rosette.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/round_dance.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/sorting_animate.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/tree.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/two_canvases.cpython-39.pyc",
+    "Lib/turtledemo/__pycache__/yinyang.cpython-39.pyc",
+    "Lib/turtledemo/bytedesign.py",
+    "Lib/turtledemo/chaos.py",
+    "Lib/turtledemo/clock.py",
+    "Lib/turtledemo/colormixer.py",
+    "Lib/turtledemo/forest.py",
+    "Lib/turtledemo/fractalcurves.py",
+    "Lib/turtledemo/lindenmayer.py",
+    "Lib/turtledemo/minimal_hanoi.py",
+    "Lib/turtledemo/nim.py",
+    "Lib/turtledemo/paint.py",
+    "Lib/turtledemo/peace.py",
+    "Lib/turtledemo/penrose.py",
+    "Lib/turtledemo/planet_and_moon.py",
+    "Lib/turtledemo/rosette.py",
+    "Lib/turtledemo/round_dance.py",
+    "Lib/turtledemo/sorting_animate.py",
+    "Lib/turtledemo/tree.py",
+    "Lib/turtledemo/turtle.cfg",
+    "Lib/turtledemo/two_canvases.py",
+    "Lib/turtledemo/yinyang.py",
+    "Lib/types.py",
+    "Lib/typing.py",
+    "Lib/unittest/__init__.py",
+    "Lib/unittest/__main__.py",
+    "Lib/unittest/__pycache__/__init__.cpython-39.pyc",
+    "Lib/unittest/__pycache__/__main__.cpython-39.pyc",
+    "Lib/unittest/__pycache__/_log.cpython-39.pyc",
+    "Lib/unittest/__pycache__/async_case.cpython-39.pyc",
+    "Lib/unittest/__pycache__/case.cpython-39.pyc",
+    "Lib/unittest/__pycache__/loader.cpython-39.pyc",
+    "Lib/unittest/__pycache__/main.cpython-39.pyc",
+    "Lib/unittest/__pycache__/mock.cpython-39.pyc",
+    "Lib/unittest/__pycache__/result.cpython-39.pyc",
+    "Lib/unittest/__pycache__/runner.cpython-39.pyc",
+    "Lib/unittest/__pycache__/signals.cpython-39.pyc",
+    "Lib/unittest/__pycache__/suite.cpython-39.pyc",
+    "Lib/unittest/__pycache__/util.cpython-39.pyc",
+    "Lib/unittest/_log.py",
+    "Lib/unittest/async_case.py",
+    "Lib/unittest/case.py",
+    "Lib/unittest/loader.py",
+    "Lib/unittest/main.py",
+    "Lib/unittest/mock.py",
+    "Lib/unittest/result.py",
+    "Lib/unittest/runner.py",
+    "Lib/unittest/signals.py",
+    "Lib/unittest/suite.py",
+    "Lib/unittest/test/__init__.py",
+    "Lib/unittest/test/__main__.py",
+    "Lib/unittest/test/__pycache__/__init__.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/__main__.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/_test_warnings.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/dummy.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/support.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_assertions.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_async_case.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_break.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_case.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_discovery.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_functiontestcase.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_loader.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_program.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_result.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_runner.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_setups.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_skipping.cpython-39.pyc",
+    "Lib/unittest/test/__pycache__/test_suite.cpython-39.pyc",
+    "Lib/unittest/test/_test_warnings.py",
+    "Lib/unittest/test/dummy.py",
+    "Lib/unittest/test/support.py",
+    "Lib/unittest/test/test_assertions.py",
+    "Lib/unittest/test/test_async_case.py",
+    "Lib/unittest/test/test_break.py",
+    "Lib/unittest/test/test_case.py",
+    "Lib/unittest/test/test_discovery.py",
+    "Lib/unittest/test/test_functiontestcase.py",
+    "Lib/unittest/test/test_loader.py",
+    "Lib/unittest/test/test_program.py",
+    "Lib/unittest/test/test_result.py",
+    "Lib/unittest/test/test_runner.py",
+    "Lib/unittest/test/test_setups.py",
+    "Lib/unittest/test/test_skipping.py",
+    "Lib/unittest/test/test_suite.py",
+    "Lib/unittest/test/testmock/__init__.py",
+    "Lib/unittest/test/testmock/__main__.py",
+    "Lib/unittest/test/testmock/__pycache__/__init__.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/__main__.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/support.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/testasync.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/testcallable.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/testhelpers.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/testmagicmethods.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/testmock.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/testpatch.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/testsealable.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/testsentinel.cpython-39.pyc",
+    "Lib/unittest/test/testmock/__pycache__/testwith.cpython-39.pyc",
+    "Lib/unittest/test/testmock/support.py",
+    "Lib/unittest/test/testmock/testasync.py",
+    "Lib/unittest/test/testmock/testcallable.py",
+    "Lib/unittest/test/testmock/testhelpers.py",
+    "Lib/unittest/test/testmock/testmagicmethods.py",
+    "Lib/unittest/test/testmock/testmock.py",
+    "Lib/unittest/test/testmock/testpatch.py",
+    "Lib/unittest/test/testmock/testsealable.py",
+    "Lib/unittest/test/testmock/testsentinel.py",
+    "Lib/unittest/test/testmock/testwith.py",
+    "Lib/unittest/util.py",
+    "Lib/urllib/__init__.py",
+    "Lib/urllib/__pycache__/__init__.cpython-39.pyc",
+    "Lib/urllib/__pycache__/error.cpython-39.pyc",
+    "Lib/urllib/__pycache__/parse.cpython-39.pyc",
+    "Lib/urllib/__pycache__/request.cpython-39.pyc",
+    "Lib/urllib/__pycache__/response.cpython-39.pyc",
+    "Lib/urllib/__pycache__/robotparser.cpython-39.pyc",
+    "Lib/urllib/error.py",
+    "Lib/urllib/parse.py",
+    "Lib/urllib/request.py",
+    "Lib/urllib/response.py",
+    "Lib/urllib/robotparser.py",
+    "Lib/uu.py",
+    "Lib/uuid.py",
+    "Lib/venv/__init__.py",
+    "Lib/venv/__main__.py",
+    "Lib/venv/__pycache__/__init__.cpython-39.pyc",
+    "Lib/venv/__pycache__/__main__.cpython-39.pyc",
+    "Lib/venv/scripts/common/Activate.ps1",
+    "Lib/venv/scripts/common/activate",
+    "Lib/venv/scripts/nt/activate.bat",
+    "Lib/venv/scripts/nt/deactivate.bat",
+    "Lib/venv/scripts/posix/activate.csh",
+    "Lib/venv/scripts/posix/activate.fish",
+    "Lib/warnings.py",
+    "Lib/wave.py",
+    "Lib/weakref.py",
+    "Lib/webbrowser.py",
+    "Lib/wsgiref/__init__.py",
+    "Lib/wsgiref/__pycache__/__init__.cpython-39.pyc",
+    "Lib/wsgiref/__pycache__/handlers.cpython-39.pyc",
+    "Lib/wsgiref/__pycache__/headers.cpython-39.pyc",
+    "Lib/wsgiref/__pycache__/simple_server.cpython-39.pyc",
+    "Lib/wsgiref/__pycache__/util.cpython-39.pyc",
+    "Lib/wsgiref/__pycache__/validate.cpython-39.pyc",
+    "Lib/wsgiref/handlers.py",
+    "Lib/wsgiref/headers.py",
+    "Lib/wsgiref/simple_server.py",
+    "Lib/wsgiref/util.py",
+    "Lib/wsgiref/validate.py",
+    "Lib/xdrlib.py",
+    "Lib/xml/__init__.py",
+    "Lib/xml/__pycache__/__init__.cpython-39.pyc",
+    "Lib/xml/dom/NodeFilter.py",
+    "Lib/xml/dom/__init__.py",
+    "Lib/xml/dom/__pycache__/NodeFilter.cpython-39.pyc",
+    "Lib/xml/dom/__pycache__/__init__.cpython-39.pyc",
+    "Lib/xml/dom/__pycache__/domreg.cpython-39.pyc",
+    "Lib/xml/dom/__pycache__/expatbuilder.cpython-39.pyc",
+    "Lib/xml/dom/__pycache__/minicompat.cpython-39.pyc",
+    "Lib/xml/dom/__pycache__/minidom.cpython-39.pyc",
+    "Lib/xml/dom/__pycache__/pulldom.cpython-39.pyc",
+    "Lib/xml/dom/__pycache__/xmlbuilder.cpython-39.pyc",
+    "Lib/xml/dom/domreg.py",
+    "Lib/xml/dom/expatbuilder.py",
+    "Lib/xml/dom/minicompat.py",
+    "Lib/xml/dom/minidom.py",
+    "Lib/xml/dom/pulldom.py",
+    "Lib/xml/dom/xmlbuilder.py",
+    "Lib/xml/etree/ElementInclude.py",
+    "Lib/xml/etree/ElementPath.py",
+    "Lib/xml/etree/ElementTree.py",
+    "Lib/xml/etree/__init__.py",
+    "Lib/xml/etree/__pycache__/ElementInclude.cpython-39.pyc",
+    "Lib/xml/etree/__pycache__/ElementPath.cpython-39.pyc",
+    "Lib/xml/etree/__pycache__/ElementTree.cpython-39.pyc",
+    "Lib/xml/etree/__pycache__/__init__.cpython-39.pyc",
+    "Lib/xml/etree/__pycache__/cElementTree.cpython-39.pyc",
+    "Lib/xml/etree/cElementTree.py",
+    "Lib/xml/parsers/__init__.py",
+    "Lib/xml/parsers/__pycache__/__init__.cpython-39.pyc",
+    "Lib/xml/parsers/__pycache__/expat.cpython-39.pyc",
+    "Lib/xml/parsers/expat.py",
+    "Lib/xml/sax/__init__.py",
+    "Lib/xml/sax/__pycache__/__init__.cpython-39.pyc",
+    "Lib/xml/sax/__pycache__/_exceptions.cpython-39.pyc",
+    "Lib/xml/sax/__pycache__/expatreader.cpython-39.pyc",
+    "Lib/xml/sax/__pycache__/handler.cpython-39.pyc",
+    "Lib/xml/sax/__pycache__/saxutils.cpython-39.pyc",
+    "Lib/xml/sax/__pycache__/xmlreader.cpython-39.pyc",
+    "Lib/xml/sax/_exceptions.py",
+    "Lib/xml/sax/expatreader.py",
+    "Lib/xml/sax/handler.py",
+    "Lib/xml/sax/saxutils.py",
+    "Lib/xml/sax/xmlreader.py",
+    "Lib/xmlrpc/__init__.py",
+    "Lib/xmlrpc/__pycache__/__init__.cpython-39.pyc",
+    "Lib/xmlrpc/__pycache__/client.cpython-39.pyc",
+    "Lib/xmlrpc/__pycache__/server.cpython-39.pyc",
+    "Lib/xmlrpc/client.py",
+    "Lib/xmlrpc/server.py",
+    "Lib/zipapp.py",
+    "Lib/zipfile.py",
+    "Lib/zipimport.py",
+    "Lib/zoneinfo/__init__.py",
+    "Lib/zoneinfo/__pycache__/__init__.cpython-39.pyc",
+    "Lib/zoneinfo/__pycache__/_common.cpython-39.pyc",
+    "Lib/zoneinfo/__pycache__/_tzpath.cpython-39.pyc",
+    "Lib/zoneinfo/__pycache__/_zoneinfo.cpython-39.pyc",
+    "Lib/zoneinfo/_common.py",
+    "Lib/zoneinfo/_tzpath.py",
+    "Lib/zoneinfo/_zoneinfo.py",
+    "Scripts/2to3-script.py",
+    "Scripts/2to3.exe",
+    "Scripts/idle-script.py",
+    "Scripts/idle.exe",
+    "Scripts/pydoc-script.py",
+    "Scripts/pydoc.exe",
+    "Tools/demo/__pycache__/beer.cpython-39.pyc",
+    "Tools/demo/__pycache__/eiffel.cpython-39.pyc",
+    "Tools/demo/__pycache__/hanoi.cpython-39.pyc",
+    "Tools/demo/__pycache__/life.cpython-39.pyc",
+    "Tools/demo/__pycache__/markov.cpython-39.pyc",
+    "Tools/demo/__pycache__/mcast.cpython-39.pyc",
+    "Tools/demo/__pycache__/queens.cpython-39.pyc",
+    "Tools/demo/__pycache__/redemo.cpython-39.pyc",
+    "Tools/demo/__pycache__/rpython.cpython-39.pyc",
+    "Tools/demo/__pycache__/rpythond.cpython-39.pyc",
+    "Tools/demo/__pycache__/sortvisu.cpython-39.pyc",
+    "Tools/demo/__pycache__/spreadsheet.cpython-39.pyc",
+    "Tools/demo/__pycache__/vector.cpython-39.pyc",
+    "Tools/demo/beer.py",
+    "Tools/demo/eiffel.py",
+    "Tools/demo/hanoi.py",
+    "Tools/demo/life.py",
+    "Tools/demo/markov.py",
+    "Tools/demo/mcast.py",
+    "Tools/demo/queens.py",
+    "Tools/demo/redemo.py",
+    "Tools/demo/rpython.py",
+    "Tools/demo/rpythond.py",
+    "Tools/demo/sortvisu.py",
+    "Tools/demo/spreadsheet.py",
+    "Tools/demo/vector.py",
+    "Tools/i18n/__pycache__/makelocalealias.cpython-39.pyc",
+    "Tools/i18n/__pycache__/msgfmt.cpython-39.pyc",
+    "Tools/i18n/__pycache__/pygettext.cpython-39.pyc",
+    "Tools/i18n/makelocalealias.py",
+    "Tools/i18n/msgfmt.py",
+    "Tools/i18n/pygettext.py",
+    "Tools/pynche/ChipViewer.py",
+    "Tools/pynche/ColorDB.py",
+    "Tools/pynche/DetailsViewer.py",
+    "Tools/pynche/ListViewer.py",
+    "Tools/pynche/Main.py",
+    "Tools/pynche/PyncheWidget.py",
+    "Tools/pynche/StripViewer.py",
+    "Tools/pynche/Switchboard.py",
+    "Tools/pynche/TextViewer.py",
+    "Tools/pynche/TypeinViewer.py",
+    "Tools/pynche/X/rgb.txt",
+    "Tools/pynche/X/xlicense.txt",
+    "Tools/pynche/__init__.py",
+    "Tools/pynche/__pycache__/ChipViewer.cpython-39.pyc",
+    "Tools/pynche/__pycache__/ColorDB.cpython-39.pyc",
+    "Tools/pynche/__pycache__/DetailsViewer.cpython-39.pyc",
+    "Tools/pynche/__pycache__/ListViewer.cpython-39.pyc",
+    "Tools/pynche/__pycache__/Main.cpython-39.pyc",
+    "Tools/pynche/__pycache__/PyncheWidget.cpython-39.pyc",
+    "Tools/pynche/__pycache__/StripViewer.cpython-39.pyc",
+    "Tools/pynche/__pycache__/Switchboard.cpython-39.pyc",
+    "Tools/pynche/__pycache__/TextViewer.cpython-39.pyc",
+    "Tools/pynche/__pycache__/TypeinViewer.cpython-39.pyc",
+    "Tools/pynche/__pycache__/__init__.cpython-39.pyc",
+    "Tools/pynche/__pycache__/pyColorChooser.cpython-39.pyc",
+    "Tools/pynche/html40colors.txt",
+    "Tools/pynche/namedcolors.txt",
+    "Tools/pynche/pyColorChooser.py",
+    "Tools/pynche/pynche.pyw",
+    "Tools/pynche/webcolors.txt",
+    "Tools/pynche/websafe.txt",
+    "Tools/scripts/2to3.py",
+    "Tools/scripts/__pycache__/2to3.cpython-39.pyc",
+    "Tools/scripts/__pycache__/abitype.cpython-39.pyc",
+    "Tools/scripts/__pycache__/analyze_dxp.cpython-39.pyc",
+    "Tools/scripts/__pycache__/byext.cpython-39.pyc",
+    "Tools/scripts/__pycache__/byteyears.cpython-39.pyc",
+    "Tools/scripts/__pycache__/checkpip.cpython-39.pyc",
+    "Tools/scripts/__pycache__/cleanfuture.cpython-39.pyc",
+    "Tools/scripts/__pycache__/combinerefs.cpython-39.pyc",
+    "Tools/scripts/__pycache__/copytime.cpython-39.pyc",
+    "Tools/scripts/__pycache__/crlf.cpython-39.pyc",
+    "Tools/scripts/__pycache__/db2pickle.cpython-39.pyc",
+    "Tools/scripts/__pycache__/diff.cpython-39.pyc",
+    "Tools/scripts/__pycache__/dutree.cpython-39.pyc",
+    "Tools/scripts/__pycache__/eptags.cpython-39.pyc",
+    "Tools/scripts/__pycache__/find-uname.cpython-39.pyc",
+    "Tools/scripts/__pycache__/find_recursionlimit.cpython-39.pyc",
+    "Tools/scripts/__pycache__/finddiv.cpython-39.pyc",
+    "Tools/scripts/__pycache__/findlinksto.cpython-39.pyc",
+    "Tools/scripts/__pycache__/findnocoding.cpython-39.pyc",
+    "Tools/scripts/__pycache__/fixcid.cpython-39.pyc",
+    "Tools/scripts/__pycache__/fixdiv.cpython-39.pyc",
+    "Tools/scripts/__pycache__/fixheader.cpython-39.pyc",
+    "Tools/scripts/__pycache__/fixnotice.cpython-39.pyc",
+    "Tools/scripts/__pycache__/fixps.cpython-39.pyc",
+    "Tools/scripts/__pycache__/generate_opcode_h.cpython-39.pyc",
+    "Tools/scripts/__pycache__/generate_symbol_py.cpython-39.pyc",
+    "Tools/scripts/__pycache__/generate_token.cpython-39.pyc",
+    "Tools/scripts/__pycache__/get-remote-certificate.cpython-39.pyc",
+    "Tools/scripts/__pycache__/google.cpython-39.pyc",
+    "Tools/scripts/__pycache__/gprof2html.cpython-39.pyc",
+    "Tools/scripts/__pycache__/highlight.cpython-39.pyc",
+    "Tools/scripts/__pycache__/ifdef.cpython-39.pyc",
+    "Tools/scripts/__pycache__/import_diagnostics.cpython-39.pyc",
+    "Tools/scripts/__pycache__/lfcr.cpython-39.pyc",
+    "Tools/scripts/__pycache__/linktree.cpython-39.pyc",
+    "Tools/scripts/__pycache__/lll.cpython-39.pyc",
+    "Tools/scripts/__pycache__/mailerdaemon.cpython-39.pyc",
+    "Tools/scripts/__pycache__/make_ctype.cpython-39.pyc",
+    "Tools/scripts/__pycache__/md5sum.cpython-39.pyc",
+    "Tools/scripts/__pycache__/mkreal.cpython-39.pyc",
+    "Tools/scripts/__pycache__/ndiff.cpython-39.pyc",
+    "Tools/scripts/__pycache__/nm2def.cpython-39.pyc",
+    "Tools/scripts/__pycache__/objgraph.cpython-39.pyc",
+    "Tools/scripts/__pycache__/parse_html5_entities.cpython-39.pyc",
+    "Tools/scripts/__pycache__/parseentities.cpython-39.pyc",
+    "Tools/scripts/__pycache__/patchcheck.cpython-39.pyc",
+    "Tools/scripts/__pycache__/pathfix.cpython-39.pyc",
+    "Tools/scripts/__pycache__/pdeps.cpython-39.pyc",
+    "Tools/scripts/__pycache__/pep384_macrocheck.cpython-39.pyc",
+    "Tools/scripts/__pycache__/pickle2db.cpython-39.pyc",
+    "Tools/scripts/__pycache__/pindent.cpython-39.pyc",
+    "Tools/scripts/__pycache__/ptags.cpython-39.pyc",
+    "Tools/scripts/__pycache__/pydoc3.cpython-39.pyc",
+    "Tools/scripts/__pycache__/pysource.cpython-39.pyc",
+    "Tools/scripts/__pycache__/reindent-rst.cpython-39.pyc",
+    "Tools/scripts/__pycache__/reindent.cpython-39.pyc",
+    "Tools/scripts/__pycache__/rgrep.cpython-39.pyc",
+    "Tools/scripts/__pycache__/run_tests.cpython-39.pyc",
+    "Tools/scripts/__pycache__/serve.cpython-39.pyc",
+    "Tools/scripts/__pycache__/smelly.cpython-39.pyc",
+    "Tools/scripts/__pycache__/suff.cpython-39.pyc",
+    "Tools/scripts/__pycache__/texi2html.cpython-39.pyc",
+    "Tools/scripts/__pycache__/untabify.cpython-39.pyc",
+    "Tools/scripts/__pycache__/update_file.cpython-39.pyc",
+    "Tools/scripts/__pycache__/var_access_benchmark.cpython-39.pyc",
+    "Tools/scripts/__pycache__/verify_ensurepip_wheels.cpython-39.pyc",
+    "Tools/scripts/__pycache__/which.cpython-39.pyc",
+    "Tools/scripts/__pycache__/win_add2path.cpython-39.pyc",
+    "Tools/scripts/abitype.py",
+    "Tools/scripts/analyze_dxp.py",
+    "Tools/scripts/byext.py",
+    "Tools/scripts/byteyears.py",
+    "Tools/scripts/checkpip.py",
+    "Tools/scripts/cleanfuture.py",
+    "Tools/scripts/combinerefs.py",
+    "Tools/scripts/copytime.py",
+    "Tools/scripts/crlf.py",
+    "Tools/scripts/db2pickle.py",
+    "Tools/scripts/diff.py",
+    "Tools/scripts/dutree.py",
+    "Tools/scripts/eptags.py",
+    "Tools/scripts/find-uname.py",
+    "Tools/scripts/find_recursionlimit.py",
+    "Tools/scripts/finddiv.py",
+    "Tools/scripts/findlinksto.py",
+    "Tools/scripts/findnocoding.py",
+    "Tools/scripts/fixcid.py",
+    "Tools/scripts/fixdiv.py",
+    "Tools/scripts/fixheader.py",
+    "Tools/scripts/fixnotice.py",
+    "Tools/scripts/fixps.py",
+    "Tools/scripts/generate_opcode_h.py",
+    "Tools/scripts/generate_symbol_py.py",
+    "Tools/scripts/generate_token.py",
+    "Tools/scripts/get-remote-certificate.py",
+    "Tools/scripts/google.py",
+    "Tools/scripts/gprof2html.py",
+    "Tools/scripts/highlight.py",
+    "Tools/scripts/ifdef.py",
+    "Tools/scripts/import_diagnostics.py",
+    "Tools/scripts/lfcr.py",
+    "Tools/scripts/linktree.py",
+    "Tools/scripts/lll.py",
+    "Tools/scripts/mailerdaemon.py",
+    "Tools/scripts/make_ctype.py",
+    "Tools/scripts/md5sum.py",
+    "Tools/scripts/mkreal.py",
+    "Tools/scripts/ndiff.py",
+    "Tools/scripts/nm2def.py",
+    "Tools/scripts/objgraph.py",
+    "Tools/scripts/parse_html5_entities.py",
+    "Tools/scripts/parseentities.py",
+    "Tools/scripts/patchcheck.py",
+    "Tools/scripts/pathfix.py",
+    "Tools/scripts/pdeps.py",
+    "Tools/scripts/pep384_macrocheck.py",
+    "Tools/scripts/pickle2db.py",
+    "Tools/scripts/pindent.py",
+    "Tools/scripts/ptags.py",
+    "Tools/scripts/pydoc3.py",
+    "Tools/scripts/pysource.py",
+    "Tools/scripts/reindent-rst.py",
+    "Tools/scripts/reindent.py",
+    "Tools/scripts/rgrep.py",
+    "Tools/scripts/run_tests.py",
+    "Tools/scripts/serve.py",
+    "Tools/scripts/smelly.py",
+    "Tools/scripts/suff.py",
+    "Tools/scripts/texi2html.py",
+    "Tools/scripts/untabify.py",
+    "Tools/scripts/update_file.py",
+    "Tools/scripts/var_access_benchmark.py",
+    "Tools/scripts/verify_ensurepip_wheels.py",
+    "Tools/scripts/which.py",
+    "Tools/scripts/win_add2path.py",
+    "include/Python-ast.h",
+    "include/Python.h",
+    "include/abstract.h",
+    "include/asdl.h",
+    "include/ast.h",
+    "include/bitset.h",
+    "include/bltinmodule.h",
+    "include/boolobject.h",
+    "include/bytearrayobject.h",
+    "include/bytesobject.h",
+    "include/cellobject.h",
+    "include/ceval.h",
+    "include/classobject.h",
+    "include/code.h",
+    "include/codecs.h",
+    "include/compile.h",
+    "include/complexobject.h",
+    "include/context.h",
+    "include/cpython/abstract.h",
+    "include/cpython/bytearrayobject.h",
+    "include/cpython/bytesobject.h",
+    "include/cpython/ceval.h",
+    "include/cpython/code.h",
+    "include/cpython/dictobject.h",
+    "include/cpython/fileobject.h",
+    "include/cpython/fileutils.h",
+    "include/cpython/frameobject.h",
+    "include/cpython/import.h",
+    "include/cpython/initconfig.h",
+    "include/cpython/interpreteridobject.h",
+    "include/cpython/listobject.h",
+    "include/cpython/methodobject.h",
+    "include/cpython/object.h",
+    "include/cpython/objimpl.h",
+    "include/cpython/pyerrors.h",
+    "include/cpython/pylifecycle.h",
+    "include/cpython/pymem.h",
+    "include/cpython/pystate.h",
+    "include/cpython/sysmodule.h",
+    "include/cpython/traceback.h",
+    "include/cpython/tupleobject.h",
+    "include/cpython/unicodeobject.h",
+    "include/datetime.h",
+    "include/descrobject.h",
+    "include/dictobject.h",
+    "include/dynamic_annotations.h",
+    "include/enumobject.h",
+    "include/errcode.h",
+    "include/eval.h",
+    "include/exports.h",
+    "include/fileobject.h",
+    "include/fileutils.h",
+    "include/floatobject.h",
+    "include/frameobject.h",
+    "include/funcobject.h",
+    "include/genericaliasobject.h",
+    "include/genobject.h",
+    "include/graminit.h",
+    "include/grammar.h",
+    "include/import.h",
+    "include/internal/pegen_interface.h",
+    "include/internal/pycore_abstract.h",
+    "include/internal/pycore_accu.h",
+    "include/internal/pycore_atomic.h",
+    "include/internal/pycore_bytes_methods.h",
+    "include/internal/pycore_byteswap.h",
+    "include/internal/pycore_call.h",
+    "include/internal/pycore_ceval.h",
+    "include/internal/pycore_code.h",
+    "include/internal/pycore_condvar.h",
+    "include/internal/pycore_context.h",
+    "include/internal/pycore_dtoa.h",
+    "include/internal/pycore_fileutils.h",
+    "include/internal/pycore_gc.h",
+    "include/internal/pycore_getopt.h",
+    "include/internal/pycore_gil.h",
+    "include/internal/pycore_hamt.h",
+    "include/internal/pycore_hashtable.h",
+    "include/internal/pycore_import.h",
+    "include/internal/pycore_initconfig.h",
+    "include/internal/pycore_interp.h",
+    "include/internal/pycore_long.h",
+    "include/internal/pycore_object.h",
+    "include/internal/pycore_pathconfig.h",
+    "include/internal/pycore_pyerrors.h",
+    "include/internal/pycore_pyhash.h",
+    "include/internal/pycore_pylifecycle.h",
+    "include/internal/pycore_pymem.h",
+    "include/internal/pycore_pystate.h",
+    "include/internal/pycore_runtime.h",
+    "include/internal/pycore_sysmodule.h",
+    "include/internal/pycore_traceback.h",
+    "include/internal/pycore_tupleobject.h",
+    "include/internal/pycore_warnings.h",
+    "include/interpreteridobject.h",
+    "include/intrcheck.h",
+    "include/iterobject.h",
+    "include/listobject.h",
+    "include/longintrepr.h",
+    "include/longobject.h",
+    "include/marshal.h",
+    "include/memoryobject.h",
+    "include/methodobject.h",
+    "include/modsupport.h",
+    "include/moduleobject.h",
+    "include/namespaceobject.h",
+    "include/node.h",
+    "include/object.h",
+    "include/objimpl.h",
+    "include/odictobject.h",
+    "include/opcode.h",
+    "include/osdefs.h",
+    "include/osmodule.h",
+    "include/parsetok.h",
+    "include/patchlevel.h",
+    "include/picklebufobject.h",
+    "include/py_curses.h",
+    "include/pyarena.h",
+    "include/pycapsule.h",
+    "include/pyconfig.h",
+    "include/pyctype.h",
+    "include/pydebug.h",
+    "include/pydtrace.d",
+    "include/pydtrace.h",
+    "include/pyerrors.h",
+    "include/pyexpat.h",
+    "include/pyfpe.h",
+    "include/pyframe.h",
+    "include/pyhash.h",
+    "include/pylifecycle.h",
+    "include/pymacconfig.h",
+    "include/pymacro.h",
+    "include/pymath.h",
+    "include/pymem.h",
+    "include/pyport.h",
+    "include/pystate.h",
+    "include/pystrcmp.h",
+    "include/pystrhex.h",
+    "include/pystrtod.h",
+    "include/pythonrun.h",
+    "include/pythread.h",
+    "include/pytime.h",
+    "include/rangeobject.h",
+    "include/setobject.h",
+    "include/sliceobject.h",
+    "include/structmember.h",
+    "include/structseq.h",
+    "include/symtable.h",
+    "include/sysmodule.h",
+    "include/token.h",
+    "include/traceback.h",
+    "include/tracemalloc.h",
+    "include/tupleobject.h",
+    "include/typeslots.h",
+    "include/ucnhash.h",
+    "include/unicodeobject.h",
+    "include/warnings.h",
+    "include/weakrefobject.h",
+    "libs/_tkinter.lib",
+    "libs/python3.lib",
+    "libs/python39.lib",
+    "python.exe",
+    "python.pdb",
+    "python3.dll",
+    "python39.dll",
+    "python39.pdb",
+    "pythonw.exe",
+    "pythonw.pdb",
+    "tcl/dde1.4/pkgIndex.tcl",
+    "tcl/dde1.4/tcldde14.dll",
+    "tcl/nmake/nmakehlp.c",
+    "tcl/nmake/rules.vc",
+    "tcl/nmake/targets.vc",
+    "tcl/nmake/tcl.nmake",
+    "tcl/reg1.3/pkgIndex.tcl",
+    "tcl/reg1.3/tclreg13.dll",
+    "tcl/tcl8.6/auto.tcl",
+    "tcl/tcl8.6/clock.tcl",
+    "tcl/tcl8.6/encoding/ascii.enc",
+    "tcl/tcl8.6/encoding/big5.enc",
+    "tcl/tcl8.6/encoding/cns11643.enc",
+    "tcl/tcl8.6/encoding/cp1250.enc",
+    "tcl/tcl8.6/encoding/cp1251.enc",
+    "tcl/tcl8.6/encoding/cp1252.enc",
+    "tcl/tcl8.6/encoding/cp1253.enc",
+    "tcl/tcl8.6/encoding/cp1254.enc",
+    "tcl/tcl8.6/encoding/cp1255.enc",
+    "tcl/tcl8.6/encoding/cp1256.enc",
+    "tcl/tcl8.6/encoding/cp1257.enc",
+    "tcl/tcl8.6/encoding/cp1258.enc",
+    "tcl/tcl8.6/encoding/cp437.enc",
+    "tcl/tcl8.6/encoding/cp737.enc",
+    "tcl/tcl8.6/encoding/cp775.enc",
+    "tcl/tcl8.6/encoding/cp850.enc",
+    "tcl/tcl8.6/encoding/cp852.enc",
+    "tcl/tcl8.6/encoding/cp855.enc",
+    "tcl/tcl8.6/encoding/cp857.enc",
+    "tcl/tcl8.6/encoding/cp860.enc",
+    "tcl/tcl8.6/encoding/cp861.enc",
+    "tcl/tcl8.6/encoding/cp862.enc",
+    "tcl/tcl8.6/encoding/cp863.enc",
+    "tcl/tcl8.6/encoding/cp864.enc",
+    "tcl/tcl8.6/encoding/cp865.enc",
+    "tcl/tcl8.6/encoding/cp866.enc",
+    "tcl/tcl8.6/encoding/cp869.enc",
+    "tcl/tcl8.6/encoding/cp874.enc",
+    "tcl/tcl8.6/encoding/cp932.enc",
+    "tcl/tcl8.6/encoding/cp936.enc",
+    "tcl/tcl8.6/encoding/cp949.enc",
+    "tcl/tcl8.6/encoding/cp950.enc",
+    "tcl/tcl8.6/encoding/dingbats.enc",
+    "tcl/tcl8.6/encoding/ebcdic.enc",
+    "tcl/tcl8.6/encoding/euc-cn.enc",
+    "tcl/tcl8.6/encoding/euc-jp.enc",
+    "tcl/tcl8.6/encoding/euc-kr.enc",
+    "tcl/tcl8.6/encoding/gb12345.enc",
+    "tcl/tcl8.6/encoding/gb1988.enc",
+    "tcl/tcl8.6/encoding/gb2312-raw.enc",
+    "tcl/tcl8.6/encoding/gb2312.enc",
+    "tcl/tcl8.6/encoding/iso2022-jp.enc",
+    "tcl/tcl8.6/encoding/iso2022-kr.enc",
+    "tcl/tcl8.6/encoding/iso2022.enc",
+    "tcl/tcl8.6/encoding/iso8859-1.enc",
+    "tcl/tcl8.6/encoding/iso8859-10.enc",
+    "tcl/tcl8.6/encoding/iso8859-11.enc",
+    "tcl/tcl8.6/encoding/iso8859-13.enc",
+    "tcl/tcl8.6/encoding/iso8859-14.enc",
+    "tcl/tcl8.6/encoding/iso8859-15.enc",
+    "tcl/tcl8.6/encoding/iso8859-16.enc",
+    "tcl/tcl8.6/encoding/iso8859-2.enc",
+    "tcl/tcl8.6/encoding/iso8859-3.enc",
+    "tcl/tcl8.6/encoding/iso8859-4.enc",
+    "tcl/tcl8.6/encoding/iso8859-5.enc",
+    "tcl/tcl8.6/encoding/iso8859-6.enc",
+    "tcl/tcl8.6/encoding/iso8859-7.enc",
+    "tcl/tcl8.6/encoding/iso8859-8.enc",
+    "tcl/tcl8.6/encoding/iso8859-9.enc",
+    "tcl/tcl8.6/encoding/jis0201.enc",
+    "tcl/tcl8.6/encoding/jis0208.enc",
+    "tcl/tcl8.6/encoding/jis0212.enc",
+    "tcl/tcl8.6/encoding/koi8-r.enc",
+    "tcl/tcl8.6/encoding/koi8-u.enc",
+    "tcl/tcl8.6/encoding/ksc5601.enc",
+    "tcl/tcl8.6/encoding/macCentEuro.enc",
+    "tcl/tcl8.6/encoding/macCroatian.enc",
+    "tcl/tcl8.6/encoding/macCyrillic.enc",
+    "tcl/tcl8.6/encoding/macDingbats.enc",
+    "tcl/tcl8.6/encoding/macGreek.enc",
+    "tcl/tcl8.6/encoding/macIceland.enc",
+    "tcl/tcl8.6/encoding/macJapan.enc",
+    "tcl/tcl8.6/encoding/macRoman.enc",
+    "tcl/tcl8.6/encoding/macRomania.enc",
+    "tcl/tcl8.6/encoding/macThai.enc",
+    "tcl/tcl8.6/encoding/macTurkish.enc",
+    "tcl/tcl8.6/encoding/macUkraine.enc",
+    "tcl/tcl8.6/encoding/shiftjis.enc",
+    "tcl/tcl8.6/encoding/symbol.enc",
+    "tcl/tcl8.6/encoding/tis-620.enc",
+    "tcl/tcl8.6/history.tcl",
+    "tcl/tcl8.6/http1.0/http.tcl",
+    "tcl/tcl8.6/http1.0/pkgIndex.tcl",
+    "tcl/tcl8.6/init.tcl",
+    "tcl/tcl8.6/msgs/af.msg",
+    "tcl/tcl8.6/msgs/af_za.msg",
+    "tcl/tcl8.6/msgs/ar.msg",
+    "tcl/tcl8.6/msgs/ar_in.msg",
+    "tcl/tcl8.6/msgs/ar_jo.msg",
+    "tcl/tcl8.6/msgs/ar_lb.msg",
+    "tcl/tcl8.6/msgs/ar_sy.msg",
+    "tcl/tcl8.6/msgs/be.msg",
+    "tcl/tcl8.6/msgs/bg.msg",
+    "tcl/tcl8.6/msgs/bn.msg",
+    "tcl/tcl8.6/msgs/bn_in.msg",
+    "tcl/tcl8.6/msgs/ca.msg",
+    "tcl/tcl8.6/msgs/cs.msg",
+    "tcl/tcl8.6/msgs/da.msg",
+    "tcl/tcl8.6/msgs/de.msg",
+    "tcl/tcl8.6/msgs/de_at.msg",
+    "tcl/tcl8.6/msgs/de_be.msg",
+    "tcl/tcl8.6/msgs/el.msg",
+    "tcl/tcl8.6/msgs/en_au.msg",
+    "tcl/tcl8.6/msgs/en_be.msg",
+    "tcl/tcl8.6/msgs/en_bw.msg",
+    "tcl/tcl8.6/msgs/en_ca.msg",
+    "tcl/tcl8.6/msgs/en_gb.msg",
+    "tcl/tcl8.6/msgs/en_hk.msg",
+    "tcl/tcl8.6/msgs/en_ie.msg",
+    "tcl/tcl8.6/msgs/en_in.msg",
+    "tcl/tcl8.6/msgs/en_nz.msg",
+    "tcl/tcl8.6/msgs/en_ph.msg",
+    "tcl/tcl8.6/msgs/en_sg.msg",
+    "tcl/tcl8.6/msgs/en_za.msg",
+    "tcl/tcl8.6/msgs/en_zw.msg",
+    "tcl/tcl8.6/msgs/eo.msg",
+    "tcl/tcl8.6/msgs/es.msg",
+    "tcl/tcl8.6/msgs/es_ar.msg",
+    "tcl/tcl8.6/msgs/es_bo.msg",
+    "tcl/tcl8.6/msgs/es_cl.msg",
+    "tcl/tcl8.6/msgs/es_co.msg",
+    "tcl/tcl8.6/msgs/es_cr.msg",
+    "tcl/tcl8.6/msgs/es_do.msg",
+    "tcl/tcl8.6/msgs/es_ec.msg",
+    "tcl/tcl8.6/msgs/es_gt.msg",
+    "tcl/tcl8.6/msgs/es_hn.msg",
+    "tcl/tcl8.6/msgs/es_mx.msg",
+    "tcl/tcl8.6/msgs/es_ni.msg",
+    "tcl/tcl8.6/msgs/es_pa.msg",
+    "tcl/tcl8.6/msgs/es_pe.msg",
+    "tcl/tcl8.6/msgs/es_pr.msg",
+    "tcl/tcl8.6/msgs/es_py.msg",
+    "tcl/tcl8.6/msgs/es_sv.msg",
+    "tcl/tcl8.6/msgs/es_uy.msg",
+    "tcl/tcl8.6/msgs/es_ve.msg",
+    "tcl/tcl8.6/msgs/et.msg",
+    "tcl/tcl8.6/msgs/eu.msg",
+    "tcl/tcl8.6/msgs/eu_es.msg",
+    "tcl/tcl8.6/msgs/fa.msg",
+    "tcl/tcl8.6/msgs/fa_in.msg",
+    "tcl/tcl8.6/msgs/fa_ir.msg",
+    "tcl/tcl8.6/msgs/fi.msg",
+    "tcl/tcl8.6/msgs/fo.msg",
+    "tcl/tcl8.6/msgs/fo_fo.msg",
+    "tcl/tcl8.6/msgs/fr.msg",
+    "tcl/tcl8.6/msgs/fr_be.msg",
+    "tcl/tcl8.6/msgs/fr_ca.msg",
+    "tcl/tcl8.6/msgs/fr_ch.msg",
+    "tcl/tcl8.6/msgs/ga.msg",
+    "tcl/tcl8.6/msgs/ga_ie.msg",
+    "tcl/tcl8.6/msgs/gl.msg",
+    "tcl/tcl8.6/msgs/gl_es.msg",
+    "tcl/tcl8.6/msgs/gv.msg",
+    "tcl/tcl8.6/msgs/gv_gb.msg",
+    "tcl/tcl8.6/msgs/he.msg",
+    "tcl/tcl8.6/msgs/hi.msg",
+    "tcl/tcl8.6/msgs/hi_in.msg",
+    "tcl/tcl8.6/msgs/hr.msg",
+    "tcl/tcl8.6/msgs/hu.msg",
+    "tcl/tcl8.6/msgs/id.msg",
+    "tcl/tcl8.6/msgs/id_id.msg",
+    "tcl/tcl8.6/msgs/is.msg",
+    "tcl/tcl8.6/msgs/it.msg",
+    "tcl/tcl8.6/msgs/it_ch.msg",
+    "tcl/tcl8.6/msgs/ja.msg",
+    "tcl/tcl8.6/msgs/kl.msg",
+    "tcl/tcl8.6/msgs/kl_gl.msg",
+    "tcl/tcl8.6/msgs/ko.msg",
+    "tcl/tcl8.6/msgs/ko_kr.msg",
+    "tcl/tcl8.6/msgs/kok.msg",
+    "tcl/tcl8.6/msgs/kok_in.msg",
+    "tcl/tcl8.6/msgs/kw.msg",
+    "tcl/tcl8.6/msgs/kw_gb.msg",
+    "tcl/tcl8.6/msgs/lt.msg",
+    "tcl/tcl8.6/msgs/lv.msg",
+    "tcl/tcl8.6/msgs/mk.msg",
+    "tcl/tcl8.6/msgs/mr.msg",
+    "tcl/tcl8.6/msgs/mr_in.msg",
+    "tcl/tcl8.6/msgs/ms.msg",
+    "tcl/tcl8.6/msgs/ms_my.msg",
+    "tcl/tcl8.6/msgs/mt.msg",
+    "tcl/tcl8.6/msgs/nb.msg",
+    "tcl/tcl8.6/msgs/nl.msg",
+    "tcl/tcl8.6/msgs/nl_be.msg",
+    "tcl/tcl8.6/msgs/nn.msg",
+    "tcl/tcl8.6/msgs/pl.msg",
+    "tcl/tcl8.6/msgs/pt.msg",
+    "tcl/tcl8.6/msgs/pt_br.msg",
+    "tcl/tcl8.6/msgs/ro.msg",
+    "tcl/tcl8.6/msgs/ru.msg",
+    "tcl/tcl8.6/msgs/ru_ua.msg",
+    "tcl/tcl8.6/msgs/sh.msg",
+    "tcl/tcl8.6/msgs/sk.msg",
+    "tcl/tcl8.6/msgs/sl.msg",
+    "tcl/tcl8.6/msgs/sq.msg",
+    "tcl/tcl8.6/msgs/sr.msg",
+    "tcl/tcl8.6/msgs/sv.msg",
+    "tcl/tcl8.6/msgs/sw.msg",
+    "tcl/tcl8.6/msgs/ta.msg",
+    "tcl/tcl8.6/msgs/ta_in.msg",
+    "tcl/tcl8.6/msgs/te.msg",
+    "tcl/tcl8.6/msgs/te_in.msg",
+    "tcl/tcl8.6/msgs/th.msg",
+    "tcl/tcl8.6/msgs/tr.msg",
+    "tcl/tcl8.6/msgs/uk.msg",
+    "tcl/tcl8.6/msgs/vi.msg",
+    "tcl/tcl8.6/msgs/zh.msg",
+    "tcl/tcl8.6/msgs/zh_cn.msg",
+    "tcl/tcl8.6/msgs/zh_hk.msg",
+    "tcl/tcl8.6/msgs/zh_sg.msg",
+    "tcl/tcl8.6/msgs/zh_tw.msg",
+    "tcl/tcl8.6/opt0.4/optparse.tcl",
+    "tcl/tcl8.6/opt0.4/pkgIndex.tcl",
+    "tcl/tcl8.6/package.tcl",
+    "tcl/tcl8.6/parray.tcl",
+    "tcl/tcl8.6/safe.tcl",
+    "tcl/tcl8.6/tclIndex",
+    "tcl/tcl8.6/tm.tcl",
+    "tcl/tcl8.6/tzdata/Africa/Abidjan",
+    "tcl/tcl8.6/tzdata/Africa/Accra",
+    "tcl/tcl8.6/tzdata/Africa/Addis_Ababa",
+    "tcl/tcl8.6/tzdata/Africa/Algiers",
+    "tcl/tcl8.6/tzdata/Africa/Asmara",
+    "tcl/tcl8.6/tzdata/Africa/Asmera",
+    "tcl/tcl8.6/tzdata/Africa/Bamako",
+    "tcl/tcl8.6/tzdata/Africa/Bangui",
+    "tcl/tcl8.6/tzdata/Africa/Banjul",
+    "tcl/tcl8.6/tzdata/Africa/Bissau",
+    "tcl/tcl8.6/tzdata/Africa/Blantyre",
+    "tcl/tcl8.6/tzdata/Africa/Brazzaville",
+    "tcl/tcl8.6/tzdata/Africa/Bujumbura",
+    "tcl/tcl8.6/tzdata/Africa/Cairo",
+    "tcl/tcl8.6/tzdata/Africa/Casablanca",
+    "tcl/tcl8.6/tzdata/Africa/Ceuta",
+    "tcl/tcl8.6/tzdata/Africa/Conakry",
+    "tcl/tcl8.6/tzdata/Africa/Dakar",
+    "tcl/tcl8.6/tzdata/Africa/Dar_es_Salaam",
+    "tcl/tcl8.6/tzdata/Africa/Djibouti",
+    "tcl/tcl8.6/tzdata/Africa/Douala",
+    "tcl/tcl8.6/tzdata/Africa/El_Aaiun",
+    "tcl/tcl8.6/tzdata/Africa/Freetown",
+    "tcl/tcl8.6/tzdata/Africa/Gaborone",
+    "tcl/tcl8.6/tzdata/Africa/Harare",
+    "tcl/tcl8.6/tzdata/Africa/Johannesburg",
+    "tcl/tcl8.6/tzdata/Africa/Juba",
+    "tcl/tcl8.6/tzdata/Africa/Kampala",
+    "tcl/tcl8.6/tzdata/Africa/Khartoum",
+    "tcl/tcl8.6/tzdata/Africa/Kigali",
+    "tcl/tcl8.6/tzdata/Africa/Kinshasa",
+    "tcl/tcl8.6/tzdata/Africa/Lagos",
+    "tcl/tcl8.6/tzdata/Africa/Libreville",
+    "tcl/tcl8.6/tzdata/Africa/Lome",
+    "tcl/tcl8.6/tzdata/Africa/Luanda",
+    "tcl/tcl8.6/tzdata/Africa/Lubumbashi",
+    "tcl/tcl8.6/tzdata/Africa/Lusaka",
+    "tcl/tcl8.6/tzdata/Africa/Malabo",
+    "tcl/tcl8.6/tzdata/Africa/Maputo",
+    "tcl/tcl8.6/tzdata/Africa/Maseru",
+    "tcl/tcl8.6/tzdata/Africa/Mbabane",
+    "tcl/tcl8.6/tzdata/Africa/Mogadishu",
+    "tcl/tcl8.6/tzdata/Africa/Monrovia",
+    "tcl/tcl8.6/tzdata/Africa/Nairobi",
+    "tcl/tcl8.6/tzdata/Africa/Ndjamena",
+    "tcl/tcl8.6/tzdata/Africa/Niamey",
+    "tcl/tcl8.6/tzdata/Africa/Nouakchott",
+    "tcl/tcl8.6/tzdata/Africa/Ouagadougou",
+    "tcl/tcl8.6/tzdata/Africa/Porto-Novo",
+    "tcl/tcl8.6/tzdata/Africa/Sao_Tome",
+    "tcl/tcl8.6/tzdata/Africa/Timbuktu",
+    "tcl/tcl8.6/tzdata/Africa/Tripoli",
+    "tcl/tcl8.6/tzdata/Africa/Tunis",
+    "tcl/tcl8.6/tzdata/Africa/Windhoek",
+    "tcl/tcl8.6/tzdata/America/Adak",
+    "tcl/tcl8.6/tzdata/America/Anchorage",
+    "tcl/tcl8.6/tzdata/America/Anguilla",
+    "tcl/tcl8.6/tzdata/America/Antigua",
+    "tcl/tcl8.6/tzdata/America/Araguaina",
+    "tcl/tcl8.6/tzdata/America/Argentina/Buenos_Aires",
+    "tcl/tcl8.6/tzdata/America/Argentina/Catamarca",
+    "tcl/tcl8.6/tzdata/America/Argentina/ComodRivadavia",
+    "tcl/tcl8.6/tzdata/America/Argentina/Cordoba",
+    "tcl/tcl8.6/tzdata/America/Argentina/Jujuy",
+    "tcl/tcl8.6/tzdata/America/Argentina/La_Rioja",
+    "tcl/tcl8.6/tzdata/America/Argentina/Mendoza",
+    "tcl/tcl8.6/tzdata/America/Argentina/Rio_Gallegos",
+    "tcl/tcl8.6/tzdata/America/Argentina/Salta",
+    "tcl/tcl8.6/tzdata/America/Argentina/San_Juan",
+    "tcl/tcl8.6/tzdata/America/Argentina/San_Luis",
+    "tcl/tcl8.6/tzdata/America/Argentina/Tucuman",
+    "tcl/tcl8.6/tzdata/America/Argentina/Ushuaia",
+    "tcl/tcl8.6/tzdata/America/Aruba",
+    "tcl/tcl8.6/tzdata/America/Asuncion",
+    "tcl/tcl8.6/tzdata/America/Atikokan",
+    "tcl/tcl8.6/tzdata/America/Atka",
+    "tcl/tcl8.6/tzdata/America/Bahia",
+    "tcl/tcl8.6/tzdata/America/Bahia_Banderas",
+    "tcl/tcl8.6/tzdata/America/Barbados",
+    "tcl/tcl8.6/tzdata/America/Belem",
+    "tcl/tcl8.6/tzdata/America/Belize",
+    "tcl/tcl8.6/tzdata/America/Blanc-Sablon",
+    "tcl/tcl8.6/tzdata/America/Boa_Vista",
+    "tcl/tcl8.6/tzdata/America/Bogota",
+    "tcl/tcl8.6/tzdata/America/Boise",
+    "tcl/tcl8.6/tzdata/America/Buenos_Aires",
+    "tcl/tcl8.6/tzdata/America/Cambridge_Bay",
+    "tcl/tcl8.6/tzdata/America/Campo_Grande",
+    "tcl/tcl8.6/tzdata/America/Cancun",
+    "tcl/tcl8.6/tzdata/America/Caracas",
+    "tcl/tcl8.6/tzdata/America/Catamarca",
+    "tcl/tcl8.6/tzdata/America/Cayenne",
+    "tcl/tcl8.6/tzdata/America/Cayman",
+    "tcl/tcl8.6/tzdata/America/Chicago",
+    "tcl/tcl8.6/tzdata/America/Chihuahua",
+    "tcl/tcl8.6/tzdata/America/Coral_Harbour",
+    "tcl/tcl8.6/tzdata/America/Cordoba",
+    "tcl/tcl8.6/tzdata/America/Costa_Rica",
+    "tcl/tcl8.6/tzdata/America/Creston",
+    "tcl/tcl8.6/tzdata/America/Cuiaba",
+    "tcl/tcl8.6/tzdata/America/Curacao",
+    "tcl/tcl8.6/tzdata/America/Danmarkshavn",
+    "tcl/tcl8.6/tzdata/America/Dawson",
+    "tcl/tcl8.6/tzdata/America/Dawson_Creek",
+    "tcl/tcl8.6/tzdata/America/Denver",
+    "tcl/tcl8.6/tzdata/America/Detroit",
+    "tcl/tcl8.6/tzdata/America/Dominica",
+    "tcl/tcl8.6/tzdata/America/Edmonton",
+    "tcl/tcl8.6/tzdata/America/Eirunepe",
+    "tcl/tcl8.6/tzdata/America/El_Salvador",
+    "tcl/tcl8.6/tzdata/America/Ensenada",
+    "tcl/tcl8.6/tzdata/America/Fort_Nelson",
+    "tcl/tcl8.6/tzdata/America/Fort_Wayne",
+    "tcl/tcl8.6/tzdata/America/Fortaleza",
+    "tcl/tcl8.6/tzdata/America/Glace_Bay",
+    "tcl/tcl8.6/tzdata/America/Godthab",
+    "tcl/tcl8.6/tzdata/America/Goose_Bay",
+    "tcl/tcl8.6/tzdata/America/Grand_Turk",
+    "tcl/tcl8.6/tzdata/America/Grenada",
+    "tcl/tcl8.6/tzdata/America/Guadeloupe",
+    "tcl/tcl8.6/tzdata/America/Guatemala",
+    "tcl/tcl8.6/tzdata/America/Guayaquil",
+    "tcl/tcl8.6/tzdata/America/Guyana",
+    "tcl/tcl8.6/tzdata/America/Halifax",
+    "tcl/tcl8.6/tzdata/America/Havana",
+    "tcl/tcl8.6/tzdata/America/Hermosillo",
+    "tcl/tcl8.6/tzdata/America/Indiana/Indianapolis",
+    "tcl/tcl8.6/tzdata/America/Indiana/Knox",
+    "tcl/tcl8.6/tzdata/America/Indiana/Marengo",
+    "tcl/tcl8.6/tzdata/America/Indiana/Petersburg",
+    "tcl/tcl8.6/tzdata/America/Indiana/Tell_City",
+    "tcl/tcl8.6/tzdata/America/Indiana/Vevay",
+    "tcl/tcl8.6/tzdata/America/Indiana/Vincennes",
+    "tcl/tcl8.6/tzdata/America/Indiana/Winamac",
+    "tcl/tcl8.6/tzdata/America/Indianapolis",
+    "tcl/tcl8.6/tzdata/America/Inuvik",
+    "tcl/tcl8.6/tzdata/America/Iqaluit",
+    "tcl/tcl8.6/tzdata/America/Jamaica",
+    "tcl/tcl8.6/tzdata/America/Jujuy",
+    "tcl/tcl8.6/tzdata/America/Juneau",
+    "tcl/tcl8.6/tzdata/America/Kentucky/Louisville",
+    "tcl/tcl8.6/tzdata/America/Kentucky/Monticello",
+    "tcl/tcl8.6/tzdata/America/Knox_IN",
+    "tcl/tcl8.6/tzdata/America/Kralendijk",
+    "tcl/tcl8.6/tzdata/America/La_Paz",
+    "tcl/tcl8.6/tzdata/America/Lima",
+    "tcl/tcl8.6/tzdata/America/Los_Angeles",
+    "tcl/tcl8.6/tzdata/America/Louisville",
+    "tcl/tcl8.6/tzdata/America/Lower_Princes",
+    "tcl/tcl8.6/tzdata/America/Maceio",
+    "tcl/tcl8.6/tzdata/America/Managua",
+    "tcl/tcl8.6/tzdata/America/Manaus",
+    "tcl/tcl8.6/tzdata/America/Marigot",
+    "tcl/tcl8.6/tzdata/America/Martinique",
+    "tcl/tcl8.6/tzdata/America/Matamoros",
+    "tcl/tcl8.6/tzdata/America/Mazatlan",
+    "tcl/tcl8.6/tzdata/America/Mendoza",
+    "tcl/tcl8.6/tzdata/America/Menominee",
+    "tcl/tcl8.6/tzdata/America/Merida",
+    "tcl/tcl8.6/tzdata/America/Metlakatla",
+    "tcl/tcl8.6/tzdata/America/Mexico_City",
+    "tcl/tcl8.6/tzdata/America/Miquelon",
+    "tcl/tcl8.6/tzdata/America/Moncton",
+    "tcl/tcl8.6/tzdata/America/Monterrey",
+    "tcl/tcl8.6/tzdata/America/Montevideo",
+    "tcl/tcl8.6/tzdata/America/Montreal",
+    "tcl/tcl8.6/tzdata/America/Montserrat",
+    "tcl/tcl8.6/tzdata/America/Nassau",
+    "tcl/tcl8.6/tzdata/America/New_York",
+    "tcl/tcl8.6/tzdata/America/Nipigon",
+    "tcl/tcl8.6/tzdata/America/Nome",
+    "tcl/tcl8.6/tzdata/America/Noronha",
+    "tcl/tcl8.6/tzdata/America/North_Dakota/Beulah",
+    "tcl/tcl8.6/tzdata/America/North_Dakota/Center",
+    "tcl/tcl8.6/tzdata/America/North_Dakota/New_Salem",
+    "tcl/tcl8.6/tzdata/America/Nuuk",
+    "tcl/tcl8.6/tzdata/America/Ojinaga",
+    "tcl/tcl8.6/tzdata/America/Panama",
+    "tcl/tcl8.6/tzdata/America/Pangnirtung",
+    "tcl/tcl8.6/tzdata/America/Paramaribo",
+    "tcl/tcl8.6/tzdata/America/Phoenix",
+    "tcl/tcl8.6/tzdata/America/Port-au-Prince",
+    "tcl/tcl8.6/tzdata/America/Port_of_Spain",
+    "tcl/tcl8.6/tzdata/America/Porto_Acre",
+    "tcl/tcl8.6/tzdata/America/Porto_Velho",
+    "tcl/tcl8.6/tzdata/America/Puerto_Rico",
+    "tcl/tcl8.6/tzdata/America/Punta_Arenas",
+    "tcl/tcl8.6/tzdata/America/Rainy_River",
+    "tcl/tcl8.6/tzdata/America/Rankin_Inlet",
+    "tcl/tcl8.6/tzdata/America/Recife",
+    "tcl/tcl8.6/tzdata/America/Regina",
+    "tcl/tcl8.6/tzdata/America/Resolute",
+    "tcl/tcl8.6/tzdata/America/Rio_Branco",
+    "tcl/tcl8.6/tzdata/America/Rosario",
+    "tcl/tcl8.6/tzdata/America/Santa_Isabel",
+    "tcl/tcl8.6/tzdata/America/Santarem",
+    "tcl/tcl8.6/tzdata/America/Santiago",
+    "tcl/tcl8.6/tzdata/America/Santo_Domingo",
+    "tcl/tcl8.6/tzdata/America/Sao_Paulo",
+    "tcl/tcl8.6/tzdata/America/Scoresbysund",
+    "tcl/tcl8.6/tzdata/America/Shiprock",
+    "tcl/tcl8.6/tzdata/America/Sitka",
+    "tcl/tcl8.6/tzdata/America/St_Barthelemy",
+    "tcl/tcl8.6/tzdata/America/St_Johns",
+    "tcl/tcl8.6/tzdata/America/St_Kitts",
+    "tcl/tcl8.6/tzdata/America/St_Lucia",
+    "tcl/tcl8.6/tzdata/America/St_Thomas",
+    "tcl/tcl8.6/tzdata/America/St_Vincent",
+    "tcl/tcl8.6/tzdata/America/Swift_Current",
+    "tcl/tcl8.6/tzdata/America/Tegucigalpa",
+    "tcl/tcl8.6/tzdata/America/Thule",
+    "tcl/tcl8.6/tzdata/America/Thunder_Bay",
+    "tcl/tcl8.6/tzdata/America/Tijuana",
+    "tcl/tcl8.6/tzdata/America/Toronto",
+    "tcl/tcl8.6/tzdata/America/Tortola",
+    "tcl/tcl8.6/tzdata/America/Vancouver",
+    "tcl/tcl8.6/tzdata/America/Virgin",
+    "tcl/tcl8.6/tzdata/America/Whitehorse",
+    "tcl/tcl8.6/tzdata/America/Winnipeg",
+    "tcl/tcl8.6/tzdata/America/Yakutat",
+    "tcl/tcl8.6/tzdata/America/Yellowknife",
+    "tcl/tcl8.6/tzdata/Antarctica/Casey",
+    "tcl/tcl8.6/tzdata/Antarctica/Davis",
+    "tcl/tcl8.6/tzdata/Antarctica/DumontDUrville",
+    "tcl/tcl8.6/tzdata/Antarctica/Macquarie",
+    "tcl/tcl8.6/tzdata/Antarctica/Mawson",
+    "tcl/tcl8.6/tzdata/Antarctica/McMurdo",
+    "tcl/tcl8.6/tzdata/Antarctica/Palmer",
+    "tcl/tcl8.6/tzdata/Antarctica/Rothera",
+    "tcl/tcl8.6/tzdata/Antarctica/South_Pole",
+    "tcl/tcl8.6/tzdata/Antarctica/Syowa",
+    "tcl/tcl8.6/tzdata/Antarctica/Troll",
+    "tcl/tcl8.6/tzdata/Antarctica/Vostok",
+    "tcl/tcl8.6/tzdata/Arctic/Longyearbyen",
+    "tcl/tcl8.6/tzdata/Asia/Aden",
+    "tcl/tcl8.6/tzdata/Asia/Almaty",
+    "tcl/tcl8.6/tzdata/Asia/Amman",
+    "tcl/tcl8.6/tzdata/Asia/Anadyr",
+    "tcl/tcl8.6/tzdata/Asia/Aqtau",
+    "tcl/tcl8.6/tzdata/Asia/Aqtobe",
+    "tcl/tcl8.6/tzdata/Asia/Ashgabat",
+    "tcl/tcl8.6/tzdata/Asia/Ashkhabad",
+    "tcl/tcl8.6/tzdata/Asia/Atyrau",
+    "tcl/tcl8.6/tzdata/Asia/Baghdad",
+    "tcl/tcl8.6/tzdata/Asia/Bahrain",
+    "tcl/tcl8.6/tzdata/Asia/Baku",
+    "tcl/tcl8.6/tzdata/Asia/Bangkok",
+    "tcl/tcl8.6/tzdata/Asia/Barnaul",
+    "tcl/tcl8.6/tzdata/Asia/Beirut",
+    "tcl/tcl8.6/tzdata/Asia/Bishkek",
+    "tcl/tcl8.6/tzdata/Asia/Brunei",
+    "tcl/tcl8.6/tzdata/Asia/Calcutta",
+    "tcl/tcl8.6/tzdata/Asia/Chita",
+    "tcl/tcl8.6/tzdata/Asia/Choibalsan",
+    "tcl/tcl8.6/tzdata/Asia/Chongqing",
+    "tcl/tcl8.6/tzdata/Asia/Chungking",
+    "tcl/tcl8.6/tzdata/Asia/Colombo",
+    "tcl/tcl8.6/tzdata/Asia/Dacca",
+    "tcl/tcl8.6/tzdata/Asia/Damascus",
+    "tcl/tcl8.6/tzdata/Asia/Dhaka",
+    "tcl/tcl8.6/tzdata/Asia/Dili",
+    "tcl/tcl8.6/tzdata/Asia/Dubai",
+    "tcl/tcl8.6/tzdata/Asia/Dushanbe",
+    "tcl/tcl8.6/tzdata/Asia/Famagusta",
+    "tcl/tcl8.6/tzdata/Asia/Gaza",
+    "tcl/tcl8.6/tzdata/Asia/Harbin",
+    "tcl/tcl8.6/tzdata/Asia/Hebron",
+    "tcl/tcl8.6/tzdata/Asia/Ho_Chi_Minh",
+    "tcl/tcl8.6/tzdata/Asia/Hong_Kong",
+    "tcl/tcl8.6/tzdata/Asia/Hovd",
+    "tcl/tcl8.6/tzdata/Asia/Irkutsk",
+    "tcl/tcl8.6/tzdata/Asia/Istanbul",
+    "tcl/tcl8.6/tzdata/Asia/Jakarta",
+    "tcl/tcl8.6/tzdata/Asia/Jayapura",
+    "tcl/tcl8.6/tzdata/Asia/Jerusalem",
+    "tcl/tcl8.6/tzdata/Asia/Kabul",
+    "tcl/tcl8.6/tzdata/Asia/Kamchatka",
+    "tcl/tcl8.6/tzdata/Asia/Karachi",
+    "tcl/tcl8.6/tzdata/Asia/Kashgar",
+    "tcl/tcl8.6/tzdata/Asia/Kathmandu",
+    "tcl/tcl8.6/tzdata/Asia/Katmandu",
+    "tcl/tcl8.6/tzdata/Asia/Khandyga",
+    "tcl/tcl8.6/tzdata/Asia/Kolkata",
+    "tcl/tcl8.6/tzdata/Asia/Krasnoyarsk",
+    "tcl/tcl8.6/tzdata/Asia/Kuala_Lumpur",
+    "tcl/tcl8.6/tzdata/Asia/Kuching",
+    "tcl/tcl8.6/tzdata/Asia/Kuwait",
+    "tcl/tcl8.6/tzdata/Asia/Macao",
+    "tcl/tcl8.6/tzdata/Asia/Macau",
+    "tcl/tcl8.6/tzdata/Asia/Magadan",
+    "tcl/tcl8.6/tzdata/Asia/Makassar",
+    "tcl/tcl8.6/tzdata/Asia/Manila",
+    "tcl/tcl8.6/tzdata/Asia/Muscat",
+    "tcl/tcl8.6/tzdata/Asia/Nicosia",
+    "tcl/tcl8.6/tzdata/Asia/Novokuznetsk",
+    "tcl/tcl8.6/tzdata/Asia/Novosibirsk",
+    "tcl/tcl8.6/tzdata/Asia/Omsk",
+    "tcl/tcl8.6/tzdata/Asia/Oral",
+    "tcl/tcl8.6/tzdata/Asia/Phnom_Penh",
+    "tcl/tcl8.6/tzdata/Asia/Pontianak",
+    "tcl/tcl8.6/tzdata/Asia/Pyongyang",
+    "tcl/tcl8.6/tzdata/Asia/Qatar",
+    "tcl/tcl8.6/tzdata/Asia/Qostanay",
+    "tcl/tcl8.6/tzdata/Asia/Qyzylorda",
+    "tcl/tcl8.6/tzdata/Asia/Rangoon",
+    "tcl/tcl8.6/tzdata/Asia/Riyadh",
+    "tcl/tcl8.6/tzdata/Asia/Saigon",
+    "tcl/tcl8.6/tzdata/Asia/Sakhalin",
+    "tcl/tcl8.6/tzdata/Asia/Samarkand",
+    "tcl/tcl8.6/tzdata/Asia/Seoul",
+    "tcl/tcl8.6/tzdata/Asia/Shanghai",
+    "tcl/tcl8.6/tzdata/Asia/Singapore",
+    "tcl/tcl8.6/tzdata/Asia/Srednekolymsk",
+    "tcl/tcl8.6/tzdata/Asia/Taipei",
+    "tcl/tcl8.6/tzdata/Asia/Tashkent",
+    "tcl/tcl8.6/tzdata/Asia/Tbilisi",
+    "tcl/tcl8.6/tzdata/Asia/Tehran",
+    "tcl/tcl8.6/tzdata/Asia/Tel_Aviv",
+    "tcl/tcl8.6/tzdata/Asia/Thimbu",
+    "tcl/tcl8.6/tzdata/Asia/Thimphu",
+    "tcl/tcl8.6/tzdata/Asia/Tokyo",
+    "tcl/tcl8.6/tzdata/Asia/Tomsk",
+    "tcl/tcl8.6/tzdata/Asia/Ujung_Pandang",
+    "tcl/tcl8.6/tzdata/Asia/Ulaanbaatar",
+    "tcl/tcl8.6/tzdata/Asia/Ulan_Bator",
+    "tcl/tcl8.6/tzdata/Asia/Urumqi",
+    "tcl/tcl8.6/tzdata/Asia/Ust-Nera",
+    "tcl/tcl8.6/tzdata/Asia/Vientiane",
+    "tcl/tcl8.6/tzdata/Asia/Vladivostok",
+    "tcl/tcl8.6/tzdata/Asia/Yakutsk",
+    "tcl/tcl8.6/tzdata/Asia/Yangon",
+    "tcl/tcl8.6/tzdata/Asia/Yekaterinburg",
+    "tcl/tcl8.6/tzdata/Asia/Yerevan",
+    "tcl/tcl8.6/tzdata/Atlantic/Azores",
+    "tcl/tcl8.6/tzdata/Atlantic/Bermuda",
+    "tcl/tcl8.6/tzdata/Atlantic/Canary",
+    "tcl/tcl8.6/tzdata/Atlantic/Cape_Verde",
+    "tcl/tcl8.6/tzdata/Atlantic/Faeroe",
+    "tcl/tcl8.6/tzdata/Atlantic/Faroe",
+    "tcl/tcl8.6/tzdata/Atlantic/Jan_Mayen",
+    "tcl/tcl8.6/tzdata/Atlantic/Madeira",
+    "tcl/tcl8.6/tzdata/Atlantic/Reykjavik",
+    "tcl/tcl8.6/tzdata/Atlantic/South_Georgia",
+    "tcl/tcl8.6/tzdata/Atlantic/St_Helena",
+    "tcl/tcl8.6/tzdata/Atlantic/Stanley",
+    "tcl/tcl8.6/tzdata/Australia/ACT",
+    "tcl/tcl8.6/tzdata/Australia/Adelaide",
+    "tcl/tcl8.6/tzdata/Australia/Brisbane",
+    "tcl/tcl8.6/tzdata/Australia/Broken_Hill",
+    "tcl/tcl8.6/tzdata/Australia/Canberra",
+    "tcl/tcl8.6/tzdata/Australia/Currie",
+    "tcl/tcl8.6/tzdata/Australia/Darwin",
+    "tcl/tcl8.6/tzdata/Australia/Eucla",
+    "tcl/tcl8.6/tzdata/Australia/Hobart",
+    "tcl/tcl8.6/tzdata/Australia/LHI",
+    "tcl/tcl8.6/tzdata/Australia/Lindeman",
+    "tcl/tcl8.6/tzdata/Australia/Lord_Howe",
+    "tcl/tcl8.6/tzdata/Australia/Melbourne",
+    "tcl/tcl8.6/tzdata/Australia/NSW",
+    "tcl/tcl8.6/tzdata/Australia/North",
+    "tcl/tcl8.6/tzdata/Australia/Perth",
+    "tcl/tcl8.6/tzdata/Australia/Queensland",
+    "tcl/tcl8.6/tzdata/Australia/South",
+    "tcl/tcl8.6/tzdata/Australia/Sydney",
+    "tcl/tcl8.6/tzdata/Australia/Tasmania",
+    "tcl/tcl8.6/tzdata/Australia/Victoria",
+    "tcl/tcl8.6/tzdata/Australia/West",
+    "tcl/tcl8.6/tzdata/Australia/Yancowinna",
+    "tcl/tcl8.6/tzdata/Brazil/Acre",
+    "tcl/tcl8.6/tzdata/Brazil/DeNoronha",
+    "tcl/tcl8.6/tzdata/Brazil/East",
+    "tcl/tcl8.6/tzdata/Brazil/West",
+    "tcl/tcl8.6/tzdata/CET",
+    "tcl/tcl8.6/tzdata/CST6CDT",
+    "tcl/tcl8.6/tzdata/Canada/Atlantic",
+    "tcl/tcl8.6/tzdata/Canada/Central",
+    "tcl/tcl8.6/tzdata/Canada/East-Saskatchewan",
+    "tcl/tcl8.6/tzdata/Canada/Eastern",
+    "tcl/tcl8.6/tzdata/Canada/Mountain",
+    "tcl/tcl8.6/tzdata/Canada/Newfoundland",
+    "tcl/tcl8.6/tzdata/Canada/Pacific",
+    "tcl/tcl8.6/tzdata/Canada/Saskatchewan",
+    "tcl/tcl8.6/tzdata/Canada/Yukon",
+    "tcl/tcl8.6/tzdata/Chile/Continental",
+    "tcl/tcl8.6/tzdata/Chile/EasterIsland",
+    "tcl/tcl8.6/tzdata/Cuba",
+    "tcl/tcl8.6/tzdata/EET",
+    "tcl/tcl8.6/tzdata/EST",
+    "tcl/tcl8.6/tzdata/EST5EDT",
+    "tcl/tcl8.6/tzdata/Egypt",
+    "tcl/tcl8.6/tzdata/Eire",
+    "tcl/tcl8.6/tzdata/Etc/GMT",
+    "tcl/tcl8.6/tzdata/Etc/GMT+0",
+    "tcl/tcl8.6/tzdata/Etc/GMT+1",
+    "tcl/tcl8.6/tzdata/Etc/GMT+10",
+    "tcl/tcl8.6/tzdata/Etc/GMT+11",
+    "tcl/tcl8.6/tzdata/Etc/GMT+12",
+    "tcl/tcl8.6/tzdata/Etc/GMT+2",
+    "tcl/tcl8.6/tzdata/Etc/GMT+3",
+    "tcl/tcl8.6/tzdata/Etc/GMT+4",
+    "tcl/tcl8.6/tzdata/Etc/GMT+5",
+    "tcl/tcl8.6/tzdata/Etc/GMT+6",
+    "tcl/tcl8.6/tzdata/Etc/GMT+7",
+    "tcl/tcl8.6/tzdata/Etc/GMT+8",
+    "tcl/tcl8.6/tzdata/Etc/GMT+9",
+    "tcl/tcl8.6/tzdata/Etc/GMT-0",
+    "tcl/tcl8.6/tzdata/Etc/GMT-1",
+    "tcl/tcl8.6/tzdata/Etc/GMT-10",
+    "tcl/tcl8.6/tzdata/Etc/GMT-11",
+    "tcl/tcl8.6/tzdata/Etc/GMT-12",
+    "tcl/tcl8.6/tzdata/Etc/GMT-13",
+    "tcl/tcl8.6/tzdata/Etc/GMT-14",
+    "tcl/tcl8.6/tzdata/Etc/GMT-2",
+    "tcl/tcl8.6/tzdata/Etc/GMT-3",
+    "tcl/tcl8.6/tzdata/Etc/GMT-4",
+    "tcl/tcl8.6/tzdata/Etc/GMT-5",
+    "tcl/tcl8.6/tzdata/Etc/GMT-6",
+    "tcl/tcl8.6/tzdata/Etc/GMT-7",
+    "tcl/tcl8.6/tzdata/Etc/GMT-8",
+    "tcl/tcl8.6/tzdata/Etc/GMT-9",
+    "tcl/tcl8.6/tzdata/Etc/GMT0",
+    "tcl/tcl8.6/tzdata/Etc/Greenwich",
+    "tcl/tcl8.6/tzdata/Etc/UCT",
+    "tcl/tcl8.6/tzdata/Etc/UTC",
+    "tcl/tcl8.6/tzdata/Etc/Universal",
+    "tcl/tcl8.6/tzdata/Etc/Zulu",
+    "tcl/tcl8.6/tzdata/Europe/Amsterdam",
+    "tcl/tcl8.6/tzdata/Europe/Andorra",
+    "tcl/tcl8.6/tzdata/Europe/Astrakhan",
+    "tcl/tcl8.6/tzdata/Europe/Athens",
+    "tcl/tcl8.6/tzdata/Europe/Belfast",
+    "tcl/tcl8.6/tzdata/Europe/Belgrade",
+    "tcl/tcl8.6/tzdata/Europe/Berlin",
+    "tcl/tcl8.6/tzdata/Europe/Bratislava",
+    "tcl/tcl8.6/tzdata/Europe/Brussels",
+    "tcl/tcl8.6/tzdata/Europe/Bucharest",
+    "tcl/tcl8.6/tzdata/Europe/Budapest",
+    "tcl/tcl8.6/tzdata/Europe/Busingen",
+    "tcl/tcl8.6/tzdata/Europe/Chisinau",
+    "tcl/tcl8.6/tzdata/Europe/Copenhagen",
+    "tcl/tcl8.6/tzdata/Europe/Dublin",
+    "tcl/tcl8.6/tzdata/Europe/Gibraltar",
+    "tcl/tcl8.6/tzdata/Europe/Guernsey",
+    "tcl/tcl8.6/tzdata/Europe/Helsinki",
+    "tcl/tcl8.6/tzdata/Europe/Isle_of_Man",
+    "tcl/tcl8.6/tzdata/Europe/Istanbul",
+    "tcl/tcl8.6/tzdata/Europe/Jersey",
+    "tcl/tcl8.6/tzdata/Europe/Kaliningrad",
+    "tcl/tcl8.6/tzdata/Europe/Kiev",
+    "tcl/tcl8.6/tzdata/Europe/Kirov",
+    "tcl/tcl8.6/tzdata/Europe/Lisbon",
+    "tcl/tcl8.6/tzdata/Europe/Ljubljana",
+    "tcl/tcl8.6/tzdata/Europe/London",
+    "tcl/tcl8.6/tzdata/Europe/Luxembourg",
+    "tcl/tcl8.6/tzdata/Europe/Madrid",
+    "tcl/tcl8.6/tzdata/Europe/Malta",
+    "tcl/tcl8.6/tzdata/Europe/Mariehamn",
+    "tcl/tcl8.6/tzdata/Europe/Minsk",
+    "tcl/tcl8.6/tzdata/Europe/Monaco",
+    "tcl/tcl8.6/tzdata/Europe/Moscow",
+    "tcl/tcl8.6/tzdata/Europe/Nicosia",
+    "tcl/tcl8.6/tzdata/Europe/Oslo",
+    "tcl/tcl8.6/tzdata/Europe/Paris",
+    "tcl/tcl8.6/tzdata/Europe/Podgorica",
+    "tcl/tcl8.6/tzdata/Europe/Prague",
+    "tcl/tcl8.6/tzdata/Europe/Riga",
+    "tcl/tcl8.6/tzdata/Europe/Rome",
+    "tcl/tcl8.6/tzdata/Europe/Samara",
+    "tcl/tcl8.6/tzdata/Europe/San_Marino",
+    "tcl/tcl8.6/tzdata/Europe/Sarajevo",
+    "tcl/tcl8.6/tzdata/Europe/Saratov",
+    "tcl/tcl8.6/tzdata/Europe/Simferopol",
+    "tcl/tcl8.6/tzdata/Europe/Skopje",
+    "tcl/tcl8.6/tzdata/Europe/Sofia",
+    "tcl/tcl8.6/tzdata/Europe/Stockholm",
+    "tcl/tcl8.6/tzdata/Europe/Tallinn",
+    "tcl/tcl8.6/tzdata/Europe/Tirane",
+    "tcl/tcl8.6/tzdata/Europe/Tiraspol",
+    "tcl/tcl8.6/tzdata/Europe/Ulyanovsk",
+    "tcl/tcl8.6/tzdata/Europe/Uzhgorod",
+    "tcl/tcl8.6/tzdata/Europe/Vaduz",
+    "tcl/tcl8.6/tzdata/Europe/Vatican",
+    "tcl/tcl8.6/tzdata/Europe/Vienna",
+    "tcl/tcl8.6/tzdata/Europe/Vilnius",
+    "tcl/tcl8.6/tzdata/Europe/Volgograd",
+    "tcl/tcl8.6/tzdata/Europe/Warsaw",
+    "tcl/tcl8.6/tzdata/Europe/Zagreb",
+    "tcl/tcl8.6/tzdata/Europe/Zaporozhye",
+    "tcl/tcl8.6/tzdata/Europe/Zurich",
+    "tcl/tcl8.6/tzdata/GB",
+    "tcl/tcl8.6/tzdata/GB-Eire",
+    "tcl/tcl8.6/tzdata/GMT",
+    "tcl/tcl8.6/tzdata/GMT+0",
+    "tcl/tcl8.6/tzdata/GMT-0",
+    "tcl/tcl8.6/tzdata/GMT0",
+    "tcl/tcl8.6/tzdata/Greenwich",
+    "tcl/tcl8.6/tzdata/HST",
+    "tcl/tcl8.6/tzdata/Hongkong",
+    "tcl/tcl8.6/tzdata/Iceland",
+    "tcl/tcl8.6/tzdata/Indian/Antananarivo",
+    "tcl/tcl8.6/tzdata/Indian/Chagos",
+    "tcl/tcl8.6/tzdata/Indian/Christmas",
+    "tcl/tcl8.6/tzdata/Indian/Cocos",
+    "tcl/tcl8.6/tzdata/Indian/Comoro",
+    "tcl/tcl8.6/tzdata/Indian/Kerguelen",
+    "tcl/tcl8.6/tzdata/Indian/Mahe",
+    "tcl/tcl8.6/tzdata/Indian/Maldives",
+    "tcl/tcl8.6/tzdata/Indian/Mauritius",
+    "tcl/tcl8.6/tzdata/Indian/Mayotte",
+    "tcl/tcl8.6/tzdata/Indian/Reunion",
+    "tcl/tcl8.6/tzdata/Iran",
+    "tcl/tcl8.6/tzdata/Israel",
+    "tcl/tcl8.6/tzdata/Jamaica",
+    "tcl/tcl8.6/tzdata/Japan",
+    "tcl/tcl8.6/tzdata/Kwajalein",
+    "tcl/tcl8.6/tzdata/Libya",
+    "tcl/tcl8.6/tzdata/MET",
+    "tcl/tcl8.6/tzdata/MST",
+    "tcl/tcl8.6/tzdata/MST7MDT",
+    "tcl/tcl8.6/tzdata/Mexico/BajaNorte",
+    "tcl/tcl8.6/tzdata/Mexico/BajaSur",
+    "tcl/tcl8.6/tzdata/Mexico/General",
+    "tcl/tcl8.6/tzdata/NZ",
+    "tcl/tcl8.6/tzdata/NZ-CHAT",
+    "tcl/tcl8.6/tzdata/Navajo",
+    "tcl/tcl8.6/tzdata/PRC",
+    "tcl/tcl8.6/tzdata/PST8PDT",
+    "tcl/tcl8.6/tzdata/Pacific/Apia",
+    "tcl/tcl8.6/tzdata/Pacific/Auckland",
+    "tcl/tcl8.6/tzdata/Pacific/Bougainville",
+    "tcl/tcl8.6/tzdata/Pacific/Chatham",
+    "tcl/tcl8.6/tzdata/Pacific/Chuuk",
+    "tcl/tcl8.6/tzdata/Pacific/Easter",
+    "tcl/tcl8.6/tzdata/Pacific/Efate",
+    "tcl/tcl8.6/tzdata/Pacific/Enderbury",
+    "tcl/tcl8.6/tzdata/Pacific/Fakaofo",
+    "tcl/tcl8.6/tzdata/Pacific/Fiji",
+    "tcl/tcl8.6/tzdata/Pacific/Funafuti",
+    "tcl/tcl8.6/tzdata/Pacific/Galapagos",
+    "tcl/tcl8.6/tzdata/Pacific/Gambier",
+    "tcl/tcl8.6/tzdata/Pacific/Guadalcanal",
+    "tcl/tcl8.6/tzdata/Pacific/Guam",
+    "tcl/tcl8.6/tzdata/Pacific/Honolulu",
+    "tcl/tcl8.6/tzdata/Pacific/Johnston",
+    "tcl/tcl8.6/tzdata/Pacific/Kanton",
+    "tcl/tcl8.6/tzdata/Pacific/Kiritimati",
+    "tcl/tcl8.6/tzdata/Pacific/Kosrae",
+    "tcl/tcl8.6/tzdata/Pacific/Kwajalein",
+    "tcl/tcl8.6/tzdata/Pacific/Majuro",
+    "tcl/tcl8.6/tzdata/Pacific/Marquesas",
+    "tcl/tcl8.6/tzdata/Pacific/Midway",
+    "tcl/tcl8.6/tzdata/Pacific/Nauru",
+    "tcl/tcl8.6/tzdata/Pacific/Niue",
+    "tcl/tcl8.6/tzdata/Pacific/Norfolk",
+    "tcl/tcl8.6/tzdata/Pacific/Noumea",
+    "tcl/tcl8.6/tzdata/Pacific/Pago_Pago",
+    "tcl/tcl8.6/tzdata/Pacific/Palau",
+    "tcl/tcl8.6/tzdata/Pacific/Pitcairn",
+    "tcl/tcl8.6/tzdata/Pacific/Pohnpei",
+    "tcl/tcl8.6/tzdata/Pacific/Ponape",
+    "tcl/tcl8.6/tzdata/Pacific/Port_Moresby",
+    "tcl/tcl8.6/tzdata/Pacific/Rarotonga",
+    "tcl/tcl8.6/tzdata/Pacific/Saipan",
+    "tcl/tcl8.6/tzdata/Pacific/Samoa",
+    "tcl/tcl8.6/tzdata/Pacific/Tahiti",
+    "tcl/tcl8.6/tzdata/Pacific/Tarawa",
+    "tcl/tcl8.6/tzdata/Pacific/Tongatapu",
+    "tcl/tcl8.6/tzdata/Pacific/Truk",
+    "tcl/tcl8.6/tzdata/Pacific/Wake",
+    "tcl/tcl8.6/tzdata/Pacific/Wallis",
+    "tcl/tcl8.6/tzdata/Pacific/Yap",
+    "tcl/tcl8.6/tzdata/Poland",
+    "tcl/tcl8.6/tzdata/Portugal",
+    "tcl/tcl8.6/tzdata/ROC",
+    "tcl/tcl8.6/tzdata/ROK",
+    "tcl/tcl8.6/tzdata/Singapore",
+    "tcl/tcl8.6/tzdata/SystemV/AST4",
+    "tcl/tcl8.6/tzdata/SystemV/AST4ADT",
+    "tcl/tcl8.6/tzdata/SystemV/CST6",
+    "tcl/tcl8.6/tzdata/SystemV/CST6CDT",
+    "tcl/tcl8.6/tzdata/SystemV/EST5",
+    "tcl/tcl8.6/tzdata/SystemV/EST5EDT",
+    "tcl/tcl8.6/tzdata/SystemV/HST10",
+    "tcl/tcl8.6/tzdata/SystemV/MST7",
+    "tcl/tcl8.6/tzdata/SystemV/MST7MDT",
+    "tcl/tcl8.6/tzdata/SystemV/PST8",
+    "tcl/tcl8.6/tzdata/SystemV/PST8PDT",
+    "tcl/tcl8.6/tzdata/SystemV/YST9",
+    "tcl/tcl8.6/tzdata/SystemV/YST9YDT",
+    "tcl/tcl8.6/tzdata/Turkey",
+    "tcl/tcl8.6/tzdata/UCT",
+    "tcl/tcl8.6/tzdata/US/Alaska",
+    "tcl/tcl8.6/tzdata/US/Aleutian",
+    "tcl/tcl8.6/tzdata/US/Arizona",
+    "tcl/tcl8.6/tzdata/US/Central",
+    "tcl/tcl8.6/tzdata/US/East-Indiana",
+    "tcl/tcl8.6/tzdata/US/Eastern",
+    "tcl/tcl8.6/tzdata/US/Hawaii",
+    "tcl/tcl8.6/tzdata/US/Indiana-Starke",
+    "tcl/tcl8.6/tzdata/US/Michigan",
+    "tcl/tcl8.6/tzdata/US/Mountain",
+    "tcl/tcl8.6/tzdata/US/Pacific",
+    "tcl/tcl8.6/tzdata/US/Pacific-New",
+    "tcl/tcl8.6/tzdata/US/Samoa",
+    "tcl/tcl8.6/tzdata/UTC",
+    "tcl/tcl8.6/tzdata/Universal",
+    "tcl/tcl8.6/tzdata/W-SU",
+    "tcl/tcl8.6/tzdata/WET",
+    "tcl/tcl8.6/tzdata/Zulu",
+    "tcl/tcl8.6/word.tcl",
+    "tcl/tcl8/8.4/platform-1.0.18.tm",
+    "tcl/tcl8/8.4/platform/shell-1.1.4.tm",
+    "tcl/tcl8/8.5/msgcat-1.6.1.tm",
+    "tcl/tcl8/8.5/tcltest-2.5.3.tm",
+    "tcl/tcl8/8.6/http-2.9.5.tm",
+    "tcl/tcl86t.lib",
+    "tcl/tclConfig.sh",
+    "tcl/tclooConfig.sh",
+    "tcl/tclstub86.lib",
+    "tcl/tix8.4.3/Balloon.tcl",
+    "tcl/tix8.4.3/BtnBox.tcl",
+    "tcl/tix8.4.3/CObjView.tcl",
+    "tcl/tix8.4.3/ChkList.tcl",
+    "tcl/tix8.4.3/ComboBox.tcl",
+    "tcl/tix8.4.3/Compat.tcl",
+    "tcl/tix8.4.3/Console.tcl",
+    "tcl/tix8.4.3/Control.tcl",
+    "tcl/tix8.4.3/DefSchm.tcl",
+    "tcl/tix8.4.3/DialogS.tcl",
+    "tcl/tix8.4.3/DirBox.tcl",
+    "tcl/tix8.4.3/DirDlg.tcl",
+    "tcl/tix8.4.3/DirList.tcl",
+    "tcl/tix8.4.3/DirTree.tcl",
+    "tcl/tix8.4.3/DragDrop.tcl",
+    "tcl/tix8.4.3/DtlList.tcl",
+    "tcl/tix8.4.3/EFileBox.tcl",
+    "tcl/tix8.4.3/EFileDlg.tcl",
+    "tcl/tix8.4.3/Event.tcl",
+    "tcl/tix8.4.3/FileBox.tcl",
+    "tcl/tix8.4.3/FileCbx.tcl",
+    "tcl/tix8.4.3/FileDlg.tcl",
+    "tcl/tix8.4.3/FileEnt.tcl",
+    "tcl/tix8.4.3/FloatEnt.tcl",
+    "tcl/tix8.4.3/Grid.tcl",
+    "tcl/tix8.4.3/HList.tcl",
+    "tcl/tix8.4.3/HListDD.tcl",
+    "tcl/tix8.4.3/IconView.tcl",
+    "tcl/tix8.4.3/Init.tcl",
+    "tcl/tix8.4.3/LabEntry.tcl",
+    "tcl/tix8.4.3/LabFrame.tcl",
+    "tcl/tix8.4.3/LabWidg.tcl",
+    "tcl/tix8.4.3/ListNBk.tcl",
+    "tcl/tix8.4.3/Makefile",
+    "tcl/tix8.4.3/Meter.tcl",
+    "tcl/tix8.4.3/MultView.tcl",
+    "tcl/tix8.4.3/NoteBook.tcl",
+    "tcl/tix8.4.3/OldUtil.tcl",
+    "tcl/tix8.4.3/OptMenu.tcl",
+    "tcl/tix8.4.3/PanedWin.tcl",
+    "tcl/tix8.4.3/PopMenu.tcl",
+    "tcl/tix8.4.3/Primitiv.tcl",
+    "tcl/tix8.4.3/ResizeH.tcl",
+    "tcl/tix8.4.3/SGrid.tcl",
+    "tcl/tix8.4.3/SHList.tcl",
+    "tcl/tix8.4.3/SListBox.tcl",
+    "tcl/tix8.4.3/STList.tcl",
+    "tcl/tix8.4.3/SText.tcl",
+    "tcl/tix8.4.3/SWidget.tcl",
+    "tcl/tix8.4.3/SWindow.tcl",
+    "tcl/tix8.4.3/Select.tcl",
+    "tcl/tix8.4.3/Shell.tcl",
+    "tcl/tix8.4.3/SimpDlg.tcl",
+    "tcl/tix8.4.3/StackWin.tcl",
+    "tcl/tix8.4.3/StatBar.tcl",
+    "tcl/tix8.4.3/StdBBox.tcl",
+    "tcl/tix8.4.3/StdShell.tcl",
+    "tcl/tix8.4.3/TList.tcl",
+    "tcl/tix8.4.3/Tix.tcl",
+    "tcl/tix8.4.3/Tree.tcl",
+    "tcl/tix8.4.3/Utils.tcl",
+    "tcl/tix8.4.3/VResize.tcl",
+    "tcl/tix8.4.3/VStack.tcl",
+    "tcl/tix8.4.3/VTree.tcl",
+    "tcl/tix8.4.3/Variable.tcl",
+    "tcl/tix8.4.3/WInfo.tcl",
+    "tcl/tix8.4.3/bitmaps/act_fold.gif",
+    "tcl/tix8.4.3/bitmaps/act_fold.xbm",
+    "tcl/tix8.4.3/bitmaps/act_fold.xpm",
+    "tcl/tix8.4.3/bitmaps/balarrow.xbm",
+    "tcl/tix8.4.3/bitmaps/cbxarrow.xbm",
+    "tcl/tix8.4.3/bitmaps/ck_def.xbm",
+    "tcl/tix8.4.3/bitmaps/ck_off.xbm",
+    "tcl/tix8.4.3/bitmaps/ck_on.xbm",
+    "tcl/tix8.4.3/bitmaps/cross.xbm",
+    "tcl/tix8.4.3/bitmaps/decr.xbm",
+    "tcl/tix8.4.3/bitmaps/drop.xbm",
+    "tcl/tix8.4.3/bitmaps/file.gif",
+    "tcl/tix8.4.3/bitmaps/file.xbm",
+    "tcl/tix8.4.3/bitmaps/file.xpm",
+    "tcl/tix8.4.3/bitmaps/folder.gif",
+    "tcl/tix8.4.3/bitmaps/folder.xbm",
+    "tcl/tix8.4.3/bitmaps/folder.xpm",
+    "tcl/tix8.4.3/bitmaps/harddisk.xbm",
+    "tcl/tix8.4.3/bitmaps/hourglas.mask",
+    "tcl/tix8.4.3/bitmaps/hourglas.xbm",
+    "tcl/tix8.4.3/bitmaps/incr.xbm",
+    "tcl/tix8.4.3/bitmaps/info.gif",
+    "tcl/tix8.4.3/bitmaps/info.xpm",
+    "tcl/tix8.4.3/bitmaps/maximize.xbm",
+    "tcl/tix8.4.3/bitmaps/minimize.xbm",
+    "tcl/tix8.4.3/bitmaps/minus.gif",
+    "tcl/tix8.4.3/bitmaps/minus.xbm",
+    "tcl/tix8.4.3/bitmaps/minus.xpm",
+    "tcl/tix8.4.3/bitmaps/minusarm.gif",
+    "tcl/tix8.4.3/bitmaps/minusarm.xbm",
+    "tcl/tix8.4.3/bitmaps/minusarm.xpm",
+    "tcl/tix8.4.3/bitmaps/mktransgif.tcl",
+    "tcl/tix8.4.3/bitmaps/network.xbm",
+    "tcl/tix8.4.3/bitmaps/no_entry.gif",
+    "tcl/tix8.4.3/bitmaps/no_entry.xpm",
+    "tcl/tix8.4.3/bitmaps/openfile.xbm",
+    "tcl/tix8.4.3/bitmaps/openfold.gif",
+    "tcl/tix8.4.3/bitmaps/openfold.xbm",
+    "tcl/tix8.4.3/bitmaps/openfold.xpm",
+    "tcl/tix8.4.3/bitmaps/plus.gif",
+    "tcl/tix8.4.3/bitmaps/plus.xbm",
+    "tcl/tix8.4.3/bitmaps/plus.xpm",
+    "tcl/tix8.4.3/bitmaps/plusarm.gif",
+    "tcl/tix8.4.3/bitmaps/plusarm.xbm",
+    "tcl/tix8.4.3/bitmaps/plusarm.xpm",
+    "tcl/tix8.4.3/bitmaps/resize1.xbm",
+    "tcl/tix8.4.3/bitmaps/resize2.xbm",
+    "tcl/tix8.4.3/bitmaps/restore.xbm",
+    "tcl/tix8.4.3/bitmaps/srcfile.gif",
+    "tcl/tix8.4.3/bitmaps/srcfile.xbm",
+    "tcl/tix8.4.3/bitmaps/srcfile.xpm",
+    "tcl/tix8.4.3/bitmaps/system.xbm",
+    "tcl/tix8.4.3/bitmaps/textfile.gif",
+    "tcl/tix8.4.3/bitmaps/textfile.xbm",
+    "tcl/tix8.4.3/bitmaps/textfile.xpm",
+    "tcl/tix8.4.3/bitmaps/tick.xbm",
+    "tcl/tix8.4.3/bitmaps/warning.gif",
+    "tcl/tix8.4.3/bitmaps/warning.xpm",
+    "tcl/tix8.4.3/demos/MkChoose.tcl",
+    "tcl/tix8.4.3/demos/MkDirLis.tcl",
+    "tcl/tix8.4.3/demos/MkSample.tcl",
+    "tcl/tix8.4.3/demos/MkScroll.tcl",
+    "tcl/tix8.4.3/demos/bitmaps/about.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/bold.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/capital.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/centerj.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/code.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/combobox.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/combobox.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/drivea.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/drivea.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/exit.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/filebox.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/filebox.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/harddisk.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/harddisk.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/italic.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/justify.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/leftj.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/netw.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/netw.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/network.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/network.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/optmenu.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/rightj.xbm",
+    "tcl/tix8.4.3/demos/bitmaps/select.xpm",
+    "tcl/tix8.4.3/demos/bitmaps/tix.gif",
+    "tcl/tix8.4.3/demos/bitmaps/underlin.xbm",
+    "tcl/tix8.4.3/demos/samples/AllSampl.tcl",
+    "tcl/tix8.4.3/demos/samples/ArrowBtn.tcl",
+    "tcl/tix8.4.3/demos/samples/Balloon.tcl",
+    "tcl/tix8.4.3/demos/samples/BtnBox.tcl",
+    "tcl/tix8.4.3/demos/samples/CObjView.tcl",
+    "tcl/tix8.4.3/demos/samples/ChkList.tcl",
+    "tcl/tix8.4.3/demos/samples/CmpImg.tcl",
+    "tcl/tix8.4.3/demos/samples/CmpImg1.tcl",
+    "tcl/tix8.4.3/demos/samples/CmpImg2.tcl",
+    "tcl/tix8.4.3/demos/samples/CmpImg3.tcl",
+    "tcl/tix8.4.3/demos/samples/CmpImg4.tcl",
+    "tcl/tix8.4.3/demos/samples/ComboBox.tcl",
+    "tcl/tix8.4.3/demos/samples/Control.tcl",
+    "tcl/tix8.4.3/demos/samples/DirDlg.tcl",
+    "tcl/tix8.4.3/demos/samples/DirList.tcl",
+    "tcl/tix8.4.3/demos/samples/DirTree.tcl",
+    "tcl/tix8.4.3/demos/samples/DragDrop.tcl",
+    "tcl/tix8.4.3/demos/samples/DynTree.tcl",
+    "tcl/tix8.4.3/demos/samples/EFileDlg.tcl",
+    "tcl/tix8.4.3/demos/samples/EditGrid.tcl",
+    "tcl/tix8.4.3/demos/samples/FileDlg.tcl",
+    "tcl/tix8.4.3/demos/samples/FileEnt.tcl",
+    "tcl/tix8.4.3/demos/samples/HList1.tcl",
+    "tcl/tix8.4.3/demos/samples/LabEntry.tcl",
+    "tcl/tix8.4.3/demos/samples/LabFrame.tcl",
+    "tcl/tix8.4.3/demos/samples/ListNBK.tcl",
+    "tcl/tix8.4.3/demos/samples/Meter.tcl",
+    "tcl/tix8.4.3/demos/samples/NoteBook.tcl",
+    "tcl/tix8.4.3/demos/samples/OptMenu.tcl",
+    "tcl/tix8.4.3/demos/samples/PanedWin.tcl",
+    "tcl/tix8.4.3/demos/samples/PopMenu.tcl",
+    "tcl/tix8.4.3/demos/samples/SGrid0.tcl",
+    "tcl/tix8.4.3/demos/samples/SGrid1.tcl",
+    "tcl/tix8.4.3/demos/samples/SHList.tcl",
+    "tcl/tix8.4.3/demos/samples/SHList2.tcl",
+    "tcl/tix8.4.3/demos/samples/SListBox.tcl",
+    "tcl/tix8.4.3/demos/samples/STList1.tcl",
+    "tcl/tix8.4.3/demos/samples/STList2.tcl",
+    "tcl/tix8.4.3/demos/samples/STList3.tcl",
+    "tcl/tix8.4.3/demos/samples/SText.tcl",
+    "tcl/tix8.4.3/demos/samples/SWindow.tcl",
+    "tcl/tix8.4.3/demos/samples/Sample.tcl",
+    "tcl/tix8.4.3/demos/samples/Select.tcl",
+    "tcl/tix8.4.3/demos/samples/StdBBox.tcl",
+    "tcl/tix8.4.3/demos/samples/Tree.tcl",
+    "tcl/tix8.4.3/demos/samples/Xpm.tcl",
+    "tcl/tix8.4.3/demos/samples/Xpm1.tcl",
+    "tcl/tix8.4.3/demos/tclIndex",
+    "tcl/tix8.4.3/demos/tixwidgets.tcl",
+    "tcl/tix8.4.3/demos/widget",
+    "tcl/tix8.4.3/fs.tcl",
+    "tcl/tix8.4.3/pkgIndex.tcl",
+    "tcl/tix8.4.3/pref/10Point.fs",
+    "tcl/tix8.4.3/pref/10Point.fsc",
+    "tcl/tix8.4.3/pref/12Point.fs",
+    "tcl/tix8.4.3/pref/12Point.fsc",
+    "tcl/tix8.4.3/pref/14Point.fs",
+    "tcl/tix8.4.3/pref/14Point.fsc",
+    "tcl/tix8.4.3/pref/Bisque.cs",
+    "tcl/tix8.4.3/pref/Bisque.csc",
+    "tcl/tix8.4.3/pref/Blue.cs",
+    "tcl/tix8.4.3/pref/Blue.csc",
+    "tcl/tix8.4.3/pref/Gray.cs",
+    "tcl/tix8.4.3/pref/Gray.csc",
+    "tcl/tix8.4.3/pref/Makefile",
+    "tcl/tix8.4.3/pref/Old12Pt.fs",
+    "tcl/tix8.4.3/pref/Old14Pt.fs",
+    "tcl/tix8.4.3/pref/SGIGray.cs",
+    "tcl/tix8.4.3/pref/SGIGray.csc",
+    "tcl/tix8.4.3/pref/TK.cs",
+    "tcl/tix8.4.3/pref/TK.csc",
+    "tcl/tix8.4.3/pref/TK.fs",
+    "tcl/tix8.4.3/pref/TK.fsc",
+    "tcl/tix8.4.3/pref/TixGray.cs",
+    "tcl/tix8.4.3/pref/TixGray.csc",
+    "tcl/tix8.4.3/pref/TkWin.cs",
+    "tcl/tix8.4.3/pref/TkWin.csc",
+    "tcl/tix8.4.3/pref/TkWin.fs",
+    "tcl/tix8.4.3/pref/TkWin.fsc",
+    "tcl/tix8.4.3/pref/WmDefault.cs",
+    "tcl/tix8.4.3/pref/WmDefault.csc",
+    "tcl/tix8.4.3/pref/WmDefault.fs",
+    "tcl/tix8.4.3/pref/WmDefault.fsc",
+    "tcl/tix8.4.3/pref/WmDefault.py",
+    "tcl/tix8.4.3/pref/WmDefault.tcl",
+    "tcl/tix8.4.3/pref/WmDefault.txt",
+    "tcl/tix8.4.3/pref/pkgIndex.tcl",
+    "tcl/tix8.4.3/pref/tixmkpref",
+    "tcl/tix8.4.3/tix84.dll",
+    "tcl/tix8.4.3/tix84.lib",
+    "tcl/tk8.6/bgerror.tcl",
+    "tcl/tk8.6/button.tcl",
+    "tcl/tk8.6/choosedir.tcl",
+    "tcl/tk8.6/clrpick.tcl",
+    "tcl/tk8.6/comdlg.tcl",
+    "tcl/tk8.6/console.tcl",
+    "tcl/tk8.6/demos/README",
+    "tcl/tk8.6/demos/anilabel.tcl",
+    "tcl/tk8.6/demos/aniwave.tcl",
+    "tcl/tk8.6/demos/arrow.tcl",
+    "tcl/tk8.6/demos/bind.tcl",
+    "tcl/tk8.6/demos/bitmap.tcl",
+    "tcl/tk8.6/demos/browse",
+    "tcl/tk8.6/demos/button.tcl",
+    "tcl/tk8.6/demos/check.tcl",
+    "tcl/tk8.6/demos/clrpick.tcl",
+    "tcl/tk8.6/demos/colors.tcl",
+    "tcl/tk8.6/demos/combo.tcl",
+    "tcl/tk8.6/demos/cscroll.tcl",
+    "tcl/tk8.6/demos/ctext.tcl",
+    "tcl/tk8.6/demos/dialog1.tcl",
+    "tcl/tk8.6/demos/dialog2.tcl",
+    "tcl/tk8.6/demos/en.msg",
+    "tcl/tk8.6/demos/entry1.tcl",
+    "tcl/tk8.6/demos/entry2.tcl",
+    "tcl/tk8.6/demos/entry3.tcl",
+    "tcl/tk8.6/demos/filebox.tcl",
+    "tcl/tk8.6/demos/floor.tcl",
+    "tcl/tk8.6/demos/fontchoose.tcl",
+    "tcl/tk8.6/demos/form.tcl",
+    "tcl/tk8.6/demos/goldberg.tcl",
+    "tcl/tk8.6/demos/hello",
+    "tcl/tk8.6/demos/hscale.tcl",
+    "tcl/tk8.6/demos/icon.tcl",
+    "tcl/tk8.6/demos/image1.tcl",
+    "tcl/tk8.6/demos/image2.tcl",
+    "tcl/tk8.6/demos/images/earth.gif",
+    "tcl/tk8.6/demos/images/earthmenu.png",
+    "tcl/tk8.6/demos/images/earthris.gif",
+    "tcl/tk8.6/demos/images/flagdown.xbm",
+    "tcl/tk8.6/demos/images/flagup.xbm",
+    "tcl/tk8.6/demos/images/gray25.xbm",
+    "tcl/tk8.6/demos/images/letters.xbm",
+    "tcl/tk8.6/demos/images/noletter.xbm",
+    "tcl/tk8.6/demos/images/ouster.png",
+    "tcl/tk8.6/demos/images/pattern.xbm",
+    "tcl/tk8.6/demos/images/tcllogo.gif",
+    "tcl/tk8.6/demos/images/teapot.ppm",
+    "tcl/tk8.6/demos/items.tcl",
+    "tcl/tk8.6/demos/ixset",
+    "tcl/tk8.6/demos/knightstour.tcl",
+    "tcl/tk8.6/demos/label.tcl",
+    "tcl/tk8.6/demos/labelframe.tcl",
+    "tcl/tk8.6/demos/license.terms",
+    "tcl/tk8.6/demos/mclist.tcl",
+    "tcl/tk8.6/demos/menu.tcl",
+    "tcl/tk8.6/demos/menubu.tcl",
+    "tcl/tk8.6/demos/msgbox.tcl",
+    "tcl/tk8.6/demos/nl.msg",
+    "tcl/tk8.6/demos/paned1.tcl",
+    "tcl/tk8.6/demos/paned2.tcl",
+    "tcl/tk8.6/demos/pendulum.tcl",
+    "tcl/tk8.6/demos/plot.tcl",
+    "tcl/tk8.6/demos/puzzle.tcl",
+    "tcl/tk8.6/demos/radio.tcl",
+    "tcl/tk8.6/demos/rmt",
+    "tcl/tk8.6/demos/rolodex",
+    "tcl/tk8.6/demos/ruler.tcl",
+    "tcl/tk8.6/demos/sayings.tcl",
+    "tcl/tk8.6/demos/search.tcl",
+    "tcl/tk8.6/demos/spin.tcl",
+    "tcl/tk8.6/demos/square",
+    "tcl/tk8.6/demos/states.tcl",
+    "tcl/tk8.6/demos/style.tcl",
+    "tcl/tk8.6/demos/tclIndex",
+    "tcl/tk8.6/demos/tcolor",
+    "tcl/tk8.6/demos/text.tcl",
+    "tcl/tk8.6/demos/textpeer.tcl",
+    "tcl/tk8.6/demos/timer",
+    "tcl/tk8.6/demos/toolbar.tcl",
+    "tcl/tk8.6/demos/tree.tcl",
+    "tcl/tk8.6/demos/ttkbut.tcl",
+    "tcl/tk8.6/demos/ttkmenu.tcl",
+    "tcl/tk8.6/demos/ttknote.tcl",
+    "tcl/tk8.6/demos/ttkpane.tcl",
+    "tcl/tk8.6/demos/ttkprogress.tcl",
+    "tcl/tk8.6/demos/ttkscale.tcl",
+    "tcl/tk8.6/demos/twind.tcl",
+    "tcl/tk8.6/demos/unicodeout.tcl",
+    "tcl/tk8.6/demos/vscale.tcl",
+    "tcl/tk8.6/demos/widget",
+    "tcl/tk8.6/dialog.tcl",
+    "tcl/tk8.6/entry.tcl",
+    "tcl/tk8.6/focus.tcl",
+    "tcl/tk8.6/fontchooser.tcl",
+    "tcl/tk8.6/iconlist.tcl",
+    "tcl/tk8.6/icons.tcl",
+    "tcl/tk8.6/images/README",
+    "tcl/tk8.6/images/logo.eps",
+    "tcl/tk8.6/images/logo100.gif",
+    "tcl/tk8.6/images/logo64.gif",
+    "tcl/tk8.6/images/logoLarge.gif",
+    "tcl/tk8.6/images/logoMed.gif",
+    "tcl/tk8.6/images/pwrdLogo.eps",
+    "tcl/tk8.6/images/pwrdLogo100.gif",
+    "tcl/tk8.6/images/pwrdLogo150.gif",
+    "tcl/tk8.6/images/pwrdLogo175.gif",
+    "tcl/tk8.6/images/pwrdLogo200.gif",
+    "tcl/tk8.6/images/pwrdLogo75.gif",
+    "tcl/tk8.6/images/tai-ku.gif",
+    "tcl/tk8.6/license.terms",
+    "tcl/tk8.6/listbox.tcl",
+    "tcl/tk8.6/megawidget.tcl",
+    "tcl/tk8.6/menu.tcl",
+    "tcl/tk8.6/mkpsenc.tcl",
+    "tcl/tk8.6/msgbox.tcl",
+    "tcl/tk8.6/msgs/cs.msg",
+    "tcl/tk8.6/msgs/da.msg",
+    "tcl/tk8.6/msgs/de.msg",
+    "tcl/tk8.6/msgs/el.msg",
+    "tcl/tk8.6/msgs/en.msg",
+    "tcl/tk8.6/msgs/en_gb.msg",
+    "tcl/tk8.6/msgs/eo.msg",
+    "tcl/tk8.6/msgs/es.msg",
+    "tcl/tk8.6/msgs/fr.msg",
+    "tcl/tk8.6/msgs/hu.msg",
+    "tcl/tk8.6/msgs/it.msg",
+    "tcl/tk8.6/msgs/nl.msg",
+    "tcl/tk8.6/msgs/pl.msg",
+    "tcl/tk8.6/msgs/pt.msg",
+    "tcl/tk8.6/msgs/ru.msg",
+    "tcl/tk8.6/msgs/sv.msg",
+    "tcl/tk8.6/obsolete.tcl",
+    "tcl/tk8.6/optMenu.tcl",
+    "tcl/tk8.6/palette.tcl",
+    "tcl/tk8.6/panedwindow.tcl",
+    "tcl/tk8.6/pkgIndex.tcl",
+    "tcl/tk8.6/safetk.tcl",
+    "tcl/tk8.6/scale.tcl",
+    "tcl/tk8.6/scrlbar.tcl",
+    "tcl/tk8.6/spinbox.tcl",
+    "tcl/tk8.6/tclIndex",
+    "tcl/tk8.6/tearoff.tcl",
+    "tcl/tk8.6/text.tcl",
+    "tcl/tk8.6/tk.tcl",
+    "tcl/tk8.6/tkfbox.tcl",
+    "tcl/tk8.6/ttk/altTheme.tcl",
+    "tcl/tk8.6/ttk/aquaTheme.tcl",
+    "tcl/tk8.6/ttk/button.tcl",
+    "tcl/tk8.6/ttk/clamTheme.tcl",
+    "tcl/tk8.6/ttk/classicTheme.tcl",
+    "tcl/tk8.6/ttk/combobox.tcl",
+    "tcl/tk8.6/ttk/cursors.tcl",
+    "tcl/tk8.6/ttk/defaults.tcl",
+    "tcl/tk8.6/ttk/entry.tcl",
+    "tcl/tk8.6/ttk/fonts.tcl",
+    "tcl/tk8.6/ttk/menubutton.tcl",
+    "tcl/tk8.6/ttk/notebook.tcl",
+    "tcl/tk8.6/ttk/panedwindow.tcl",
+    "tcl/tk8.6/ttk/progress.tcl",
+    "tcl/tk8.6/ttk/scale.tcl",
+    "tcl/tk8.6/ttk/scrollbar.tcl",
+    "tcl/tk8.6/ttk/sizegrip.tcl",
+    "tcl/tk8.6/ttk/spinbox.tcl",
+    "tcl/tk8.6/ttk/treeview.tcl",
+    "tcl/tk8.6/ttk/ttk.tcl",
+    "tcl/tk8.6/ttk/utils.tcl",
+    "tcl/tk8.6/ttk/vistaTheme.tcl",
+    "tcl/tk8.6/ttk/winTheme.tcl",
+    "tcl/tk8.6/ttk/xpTheme.tcl",
+    "tcl/tk8.6/unsupported.tcl",
+    "tcl/tk8.6/xmfbox.tcl",
+    "tcl/tk86t.lib",
+    "tcl/tkstub86.lib",
+    "venvlauncher.exe",
+    "venvwlauncher.exe",
+    ".nonadmin"
+  ],
+  "fn": "python-3.9.21-h8205438_1.conda",
+  "legacy_bz2_md5": "aaa687a923bb306a95fb114db673e764",
+  "license": "PSF-2.0",
+  "license_family": "PSF",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\python-3.9.21-h8205438_1",
+    "type": 1
+  },
+  "md5": "9c3ec82d8df2feb017ef150c3b841223",
+  "name": "python",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\python-3.9.21-h8205438_1.conda",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "DLLs/_asyncio.pyd",
+        "path_type": "hardlink",
+        "sha256": "96c29922f9235751d2039668acb8416a2d825f41b6d8712a5e2b7b220b54423b",
+        "sha256_in_prefix": "96c29922f9235751d2039668acb8416a2d825f41b6d8712a5e2b7b220b54423b",
+        "size_in_bytes": 69904
+      },
+      {
+        "_path": "DLLs/_bz2.pyd",
+        "path_type": "hardlink",
+        "sha256": "70ab16ae6cad2fdd0d780807546eb8daafa7fd14efc2c8f11db4641d31e58c92",
+        "sha256_in_prefix": "70ab16ae6cad2fdd0d780807546eb8daafa7fd14efc2c8f11db4641d31e58c92",
+        "size_in_bytes": 90896
+      },
+      {
+        "_path": "DLLs/_ctypes.pyd",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "2cf80274f0c006500986d4b8ccdbebe2dad02c24e8fe77d70ca72c4d3139484f",
+        "sha256_in_prefix": "2cf80274f0c006500986d4b8ccdbebe2dad02c24e8fe77d70ca72c4d3139484f",
+        "size_in_bytes": 131344
+      },
+      {
+        "_path": "DLLs/_ctypes_test.pyd",
+        "path_type": "hardlink",
+        "sha256": "10c806a805e398cc9d0d00ceeeffc6177db6df39a61fc60fae49c52143443c6a",
+        "sha256_in_prefix": "10c806a805e398cc9d0d00ceeeffc6177db6df39a61fc60fae49c52143443c6a",
+        "size_in_bytes": 38672
+      },
+      {
+        "_path": "DLLs/_decimal.pyd",
+        "path_type": "hardlink",
+        "sha256": "fd888b188108d5cf5238ca422d43a41d07adc0c4344ccd5ff099ed928a089310",
+        "sha256_in_prefix": "fd888b188108d5cf5238ca422d43a41d07adc0c4344ccd5ff099ed928a089310",
+        "size_in_bytes": 276240
+      },
+      {
+        "_path": "DLLs/_elementtree.pyd",
+        "path_type": "hardlink",
+        "sha256": "0a364d8d03e9b11f78102c2b2f5c0a81af72e4166fdd0566f77bf360f1a36171",
+        "sha256_in_prefix": "0a364d8d03e9b11f78102c2b2f5c0a81af72e4166fdd0566f77bf360f1a36171",
+        "size_in_bytes": 195856
+      },
+      {
+        "_path": "DLLs/_hashlib.pyd",
+        "path_type": "hardlink",
+        "sha256": "0fb72e82713258d77710115d4e98953b999025f1c8e420f4fa3b53e04db5f733",
+        "sha256_in_prefix": "0fb72e82713258d77710115d4e98953b999025f1c8e420f4fa3b53e04db5f733",
+        "size_in_bytes": 69904
+      },
+      {
+        "_path": "DLLs/_lzma.pyd",
+        "path_type": "hardlink",
+        "sha256": "2aa87e895acd2dc6b4440f4bb86184830073c6d1d4ff77d1bb51823f4faf33b1",
+        "sha256_in_prefix": "2aa87e895acd2dc6b4440f4bb86184830073c6d1d4ff77d1bb51823f4faf33b1",
+        "size_in_bytes": 167696
+      },
+      {
+        "_path": "DLLs/_msi.pyd",
+        "path_type": "hardlink",
+        "sha256": "f3cf986e0a24cea4afc8fbdc518a5b1e632835d72e443b0c986f7e1de27f3012",
+        "sha256_in_prefix": "f3cf986e0a24cea4afc8fbdc518a5b1e632835d72e443b0c986f7e1de27f3012",
+        "size_in_bytes": 44816
+      },
+      {
+        "_path": "DLLs/_multiprocessing.pyd",
+        "path_type": "hardlink",
+        "sha256": "252c2c2d19485b8a255fc5434fe7b0e2f65e562e04be5cfda1dd1ab4fcb73188",
+        "sha256_in_prefix": "252c2c2d19485b8a255fc5434fe7b0e2f65e562e04be5cfda1dd1ab4fcb73188",
+        "size_in_bytes": 35088
+      },
+      {
+        "_path": "DLLs/_overlapped.pyd",
+        "path_type": "hardlink",
+        "sha256": "7829f4f6b27a3246321b95d6e9d0841c0ded9aba09e3fee6befe0d48f6d4d80d",
+        "sha256_in_prefix": "7829f4f6b27a3246321b95d6e9d0841c0ded9aba09e3fee6befe0d48f6d4d80d",
+        "size_in_bytes": 51472
+      },
+      {
+        "_path": "DLLs/_queue.pyd",
+        "path_type": "hardlink",
+        "sha256": "e54f0f3e9dab6409add97ac1ebef01947402f57091bb70052012c58301f52980",
+        "sha256_in_prefix": "e54f0f3e9dab6409add97ac1ebef01947402f57091bb70052012c58301f52980",
+        "size_in_bytes": 34064
+      },
+      {
+        "_path": "DLLs/_socket.pyd",
+        "path_type": "hardlink",
+        "sha256": "7c0b574e78a28480b21e0639134a9e3de69a97f64bca85be9fd64b18def735ca",
+        "sha256_in_prefix": "7c0b574e78a28480b21e0639134a9e3de69a97f64bca85be9fd64b18def735ca",
+        "size_in_bytes": 84752
+      },
+      {
+        "_path": "DLLs/_sqlite3.pyd",
+        "path_type": "hardlink",
+        "sha256": "8a9f4144698169a8d3203b9d221d1b88c904113f95a2430f2ceab1f8d3098662",
+        "sha256_in_prefix": "8a9f4144698169a8d3203b9d221d1b88c904113f95a2430f2ceab1f8d3098662",
+        "size_in_bytes": 88848
+      },
+      {
+        "_path": "DLLs/_ssl.pyd",
+        "path_type": "hardlink",
+        "sha256": "26d1b12e72f4eeff036c3254761b25b7a7cd5fbf6d24b33e4a3519a159dde995",
+        "sha256_in_prefix": "26d1b12e72f4eeff036c3254761b25b7a7cd5fbf6d24b33e4a3519a159dde995",
+        "size_in_bytes": 174864
+      },
+      {
+        "_path": "DLLs/_testbuffer.pyd",
+        "path_type": "hardlink",
+        "sha256": "548eb5fc99ebdc56d866b7f3658b97728f27c5d180228d7e3a06df4801ac3dda",
+        "sha256_in_prefix": "548eb5fc99ebdc56d866b7f3658b97728f27c5d180228d7e3a06df4801ac3dda",
+        "size_in_bytes": 60176
+      },
+      {
+        "_path": "DLLs/_testcapi.pyd",
+        "path_type": "hardlink",
+        "sha256": "bc1d1987fe9083f9ebe742ccdc271eea162ff7fad5cae62456d1d5827627e41c",
+        "sha256_in_prefix": "bc1d1987fe9083f9ebe742ccdc271eea162ff7fad5cae62456d1d5827627e41c",
+        "size_in_bytes": 135952
+      },
+      {
+        "_path": "DLLs/_testconsole.pyd",
+        "path_type": "hardlink",
+        "sha256": "44ee946ec958d41ecba40fbc68df2a8bf3d2b28b276b07589f95df08d03bc92f",
+        "sha256_in_prefix": "44ee946ec958d41ecba40fbc68df2a8bf3d2b28b276b07589f95df08d03bc92f",
+        "size_in_bytes": 29456
+      },
+      {
+        "_path": "DLLs/_testimportmultiple.pyd",
+        "path_type": "hardlink",
+        "sha256": "311b5b8aa773ff8e31144961bc9e1fab1b8c76a3e279586402bd14d5f6bf5b24",
+        "sha256_in_prefix": "311b5b8aa773ff8e31144961bc9e1fab1b8c76a3e279586402bd14d5f6bf5b24",
+        "size_in_bytes": 27408
+      },
+      {
+        "_path": "DLLs/_testinternalcapi.pyd",
+        "path_type": "hardlink",
+        "sha256": "3603fee99868c98feffefb558ba4bff0147efc6ce0ac5c3a7f2e25f9918843f1",
+        "sha256_in_prefix": "3603fee99868c98feffefb558ba4bff0147efc6ce0ac5c3a7f2e25f9918843f1",
+        "size_in_bytes": 31504
+      },
+      {
+        "_path": "DLLs/_testmultiphase.pyd",
+        "path_type": "hardlink",
+        "sha256": "d4b2c13646627f982482f6c8aeae728a7127671b4eb0c375143a20f3ce754a37",
+        "sha256_in_prefix": "d4b2c13646627f982482f6c8aeae728a7127671b4eb0c375143a20f3ce754a37",
+        "size_in_bytes": 39696
+      },
+      {
+        "_path": "DLLs/_tkinter.pyd",
+        "path_type": "hardlink",
+        "sha256": "1f8c62e795bbc92609b80adfac628457b8e9267a051ae49193b82c38f1ff1d19",
+        "sha256_in_prefix": "1f8c62e795bbc92609b80adfac628457b8e9267a051ae49193b82c38f1ff1d19",
+        "size_in_bytes": 70416
+      },
+      {
+        "_path": "DLLs/_uuid.pyd",
+        "path_type": "hardlink",
+        "sha256": "e3a927f4b0d917c1e91425c3282958a76884bbda2d8d5b5a6a7a2ef47b83e982",
+        "sha256_in_prefix": "e3a927f4b0d917c1e91425c3282958a76884bbda2d8d5b5a6a7a2ef47b83e982",
+        "size_in_bytes": 28432
+      },
+      {
+        "_path": "DLLs/_zoneinfo.pyd",
+        "path_type": "hardlink",
+        "sha256": "b3fbaf8f9d920688ae2407cdb0392e95740aa80107d4b03f5d2636b4960dd911",
+        "sha256_in_prefix": "b3fbaf8f9d920688ae2407cdb0392e95740aa80107d4b03f5d2636b4960dd911",
+        "size_in_bytes": 51984
+      },
+      {
+        "_path": "DLLs/libffi-7.dll",
+        "path_type": "hardlink",
+        "sha256": "f60dd9f2fcbd495674dfc1555effb710eb081fc7d4cae5fa58c438ab50405081",
+        "sha256_in_prefix": "f60dd9f2fcbd495674dfc1555effb710eb081fc7d4cae5fa58c438ab50405081",
+        "size_in_bytes": 32792
+      },
+      {
+        "_path": "DLLs/py.ico",
+        "path_type": "hardlink",
+        "sha256": "150c470f9943b806b44312efdec85755f22f8d7d52b31f93a9af3c43e8627381",
+        "sha256_in_prefix": "150c470f9943b806b44312efdec85755f22f8d7d52b31f93a9af3c43e8627381",
+        "size_in_bytes": 75809
+      },
+      {
+        "_path": "DLLs/pyc.ico",
+        "path_type": "hardlink",
+        "sha256": "fda28a734788a3f175cb6aed4daeb5f05f0e49f6a272ccd2051ba337f7b3b42f",
+        "sha256_in_prefix": "fda28a734788a3f175cb6aed4daeb5f05f0e49f6a272ccd2051ba337f7b3b42f",
+        "size_in_bytes": 78396
+      },
+      {
+        "_path": "DLLs/pyexpat.pyd",
+        "path_type": "hardlink",
+        "sha256": "ae968131e1413b1d2e116b0dba9d540644e7e3c50ccc5b920a94c5f257c2e099",
+        "sha256_in_prefix": "ae968131e1413b1d2e116b0dba9d540644e7e3c50ccc5b920a94c5f257c2e099",
+        "size_in_bytes": 211216
+      },
+      {
+        "_path": "DLLs/select.pyd",
+        "path_type": "hardlink",
+        "sha256": "afde9ecc8981b54e261321f5892e60dda47bcc2662669621620b80e7719ebd54",
+        "sha256_in_prefix": "afde9ecc8981b54e261321f5892e60dda47bcc2662669621620b80e7719ebd54",
+        "size_in_bytes": 33552
+      },
+      {
+        "_path": "DLLs/tcl86t.dll",
+        "path_type": "hardlink",
+        "sha256": "fbfd065f861ec0a90dd513bc209c56bbc23c54d2839964a0ec2df95848af7860",
+        "sha256_in_prefix": "fbfd065f861ec0a90dd513bc209c56bbc23c54d2839964a0ec2df95848af7860",
+        "size_in_bytes": 1866480
+      },
+      {
+        "_path": "DLLs/tk86t.dll",
+        "path_type": "hardlink",
+        "sha256": "cd2f60075064dfc2e65c88b239a970cb4bd07cb3eec7cc26fb1bf978d4356b08",
+        "sha256_in_prefix": "cd2f60075064dfc2e65c88b239a970cb4bd07cb3eec7cc26fb1bf978d4356b08",
+        "size_in_bytes": 1541872
+      },
+      {
+        "_path": "DLLs/unicodedata.pyd",
+        "path_type": "hardlink",
+        "sha256": "d15e5f245ee5a9a9ae4af3bad15dd557b458d564e0158c83c9c168335ba29d6a",
+        "sha256_in_prefix": "d15e5f245ee5a9a9ae4af3bad15dd557b458d564e0158c83c9c168335ba29d6a",
+        "size_in_bytes": 1126160
+      },
+      {
+        "_path": "DLLs/winsound.pyd",
+        "path_type": "hardlink",
+        "sha256": "e380956b04e7af3611cf8ace1ffb5500124e101f1af42b2d94bbc6a02dccd0a7",
+        "sha256_in_prefix": "e380956b04e7af3611cf8ace1ffb5500124e101f1af42b2d94bbc6a02dccd0a7",
+        "size_in_bytes": 34576
+      },
+      {
+        "_path": "LICENSE_PYTHON.txt",
+        "path_type": "hardlink",
+        "sha256": "0bcd0ed8d17aed30c8487847c5d92d153471dba38520e81b15312cb432c44852",
+        "sha256_in_prefix": "0bcd0ed8d17aed30c8487847c5d92d153471dba38520e81b15312cb432c44852",
+        "size_in_bytes": 13937
+      },
+      {
+        "_path": "Lib/__future__.py",
+        "path_type": "hardlink",
+        "sha256": "5373c92a824f872aa3aedadce8fe8f858c27f1abbe9a3faa0dc34f0af1984332",
+        "sha256_in_prefix": "5373c92a824f872aa3aedadce8fe8f858c27f1abbe9a3faa0dc34f0af1984332",
+        "size_in_bytes": 5147
+      },
+      {
+        "_path": "Lib/__phello__.foo.py",
+        "path_type": "hardlink",
+        "sha256": "586d9bf9b42fadd32feb1fba80613bcbfb4180dbcd6f03af678b5a6deb9d6a7b",
+        "sha256_in_prefix": "586d9bf9b42fadd32feb1fba80613bcbfb4180dbcd6f03af678b5a6deb9d6a7b",
+        "size_in_bytes": 64
+      },
+      {
+        "_path": "Lib/__pycache__/__future__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a95accfb2dab343a8b1eaefb1d115e4825cb88ab14abdafa080bead249b0f074",
+        "sha256_in_prefix": "a95accfb2dab343a8b1eaefb1d115e4825cb88ab14abdafa080bead249b0f074",
+        "size_in_bytes": 4109
+      },
+      {
+        "_path": "Lib/__pycache__/__phello__.foo.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fd605b98c5cdc4d97c85e776bcb369d2a8295029be12115158e48851175aa1fb",
+        "sha256_in_prefix": "fd605b98c5cdc4d97c85e776bcb369d2a8295029be12115158e48851175aa1fb",
+        "size_in_bytes": 112
+      },
+      {
+        "_path": "Lib/__pycache__/_aix_support.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d4d72ad6236db1be67c7f5f769c5fe6af7ae455e944f8d9873191ccea299cf0d",
+        "sha256_in_prefix": "d4d72ad6236db1be67c7f5f769c5fe6af7ae455e944f8d9873191ccea299cf0d",
+        "size_in_bytes": 3029
+      },
+      {
+        "_path": "Lib/__pycache__/_bootlocale.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0d1b15a744eac1327539c24897b8cf4e0b47976010a843865c8645d364e62157",
+        "sha256_in_prefix": "0d1b15a744eac1327539c24897b8cf4e0b47976010a843865c8645d364e62157",
+        "size_in_bytes": 1210
+      },
+      {
+        "_path": "Lib/__pycache__/_bootsubprocess.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7a5bc9ba89ff8f4e078b9b71fd2aad4f8514474342253c05f9271ae8092d7426",
+        "sha256_in_prefix": "7a5bc9ba89ff8f4e078b9b71fd2aad4f8514474342253c05f9271ae8092d7426",
+        "size_in_bytes": 2228
+      },
+      {
+        "_path": "Lib/__pycache__/_collections_abc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c4e2b841e3fc5219c5dafc2f8aa9fd5f39920fe1d9c3877bdd0f5779bb718f6d",
+        "sha256_in_prefix": "c4e2b841e3fc5219c5dafc2f8aa9fd5f39920fe1d9c3877bdd0f5779bb718f6d",
+        "size_in_bytes": 31714
+      },
+      {
+        "_path": "Lib/__pycache__/_compat_pickle.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b19a3f2c3136b8dd10b204a796b72cad1db1441a4493c815cdf45c15dfa6ac21",
+        "sha256_in_prefix": "b19a3f2c3136b8dd10b204a796b72cad1db1441a4493c815cdf45c15dfa6ac21",
+        "size_in_bytes": 5471
+      },
+      {
+        "_path": "Lib/__pycache__/_compression.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f32ae1b327b53895670fb2b9d951122f5eda202eb4f340760c03680b7c5d4e7b",
+        "sha256_in_prefix": "f32ae1b327b53895670fb2b9d951122f5eda202eb4f340760c03680b7c5d4e7b",
+        "size_in_bytes": 4181
+      },
+      {
+        "_path": "Lib/__pycache__/_markupbase.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5d61f6f61550df1ca5fde26430a33c78302494c4163989562674b9aefdd833b2",
+        "sha256_in_prefix": "5d61f6f61550df1ca5fde26430a33c78302494c4163989562674b9aefdd833b2",
+        "size_in_bytes": 7760
+      },
+      {
+        "_path": "Lib/__pycache__/_osx_support.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f73de193c839a52a45cb527b7ed1f55c8b3feca5a8c9349bde31da4a6af0d14b",
+        "sha256_in_prefix": "f73de193c839a52a45cb527b7ed1f55c8b3feca5a8c9349bde31da4a6af0d14b",
+        "size_in_bytes": 11565
+      },
+      {
+        "_path": "Lib/__pycache__/_py_abc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a84e698ce4877ba375bfc23c13098fe4df045ad5ff160790f22ce33ebd780687",
+        "sha256_in_prefix": "a84e698ce4877ba375bfc23c13098fe4df045ad5ff160790f22ce33ebd780687",
+        "size_in_bytes": 4639
+      },
+      {
+        "_path": "Lib/__pycache__/_pydecimal.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b724c8099e8d232313af72b31f1c7eb1f0e1f44b8f1cd5a7d58e310fa0634e6b",
+        "sha256_in_prefix": "b724c8099e8d232313af72b31f1c7eb1f0e1f44b8f1cd5a7d58e310fa0634e6b",
+        "size_in_bytes": 160596
+      },
+      {
+        "_path": "Lib/__pycache__/_pyio.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "56112ee7cb499adf1152b4199b220b6cdd7d497cd73a8b2ff06a419ce5f5c057",
+        "sha256_in_prefix": "56112ee7cb499adf1152b4199b220b6cdd7d497cd73a8b2ff06a419ce5f5c057",
+        "size_in_bytes": 74370
+      },
+      {
+        "_path": "Lib/__pycache__/_sitebuiltins.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "88c7e3bee8cb84ca9702fedd334d768b530b68c2904a5107c8f742073b295b31",
+        "sha256_in_prefix": "88c7e3bee8cb84ca9702fedd334d768b530b68c2904a5107c8f742073b295b31",
+        "size_in_bytes": 3484
+      },
+      {
+        "_path": "Lib/__pycache__/_strptime.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6f4b4a6eddacb5841282ea3ba26a5ba375899951dbcc348715745db1f44b7a2d",
+        "sha256_in_prefix": "6f4b4a6eddacb5841282ea3ba26a5ba375899951dbcc348715745db1f44b7a2d",
+        "size_in_bytes": 15998
+      },
+      {
+        "_path": "Lib/__pycache__/_threading_local.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "22025d8a82c720ac0e9b108f4a9de122d37415c3af592bc24f78ec8de9fee2a8",
+        "sha256_in_prefix": "22025d8a82c720ac0e9b108f4a9de122d37415c3af592bc24f78ec8de9fee2a8",
+        "size_in_bytes": 6489
+      },
+      {
+        "_path": "Lib/__pycache__/_weakrefset.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "db2a2646cbf9b2b937dc07d7b4fbf115fc6436b83c738f42e236034295def511",
+        "sha256_in_prefix": "db2a2646cbf9b2b937dc07d7b4fbf115fc6436b83c738f42e236034295def511",
+        "size_in_bytes": 7707
+      },
+      {
+        "_path": "Lib/__pycache__/abc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6e5097c8287154481dbe02a1c310b90daea6003f02f54dfad970dec8e125fb6b",
+        "sha256_in_prefix": "6e5097c8287154481dbe02a1c310b90daea6003f02f54dfad970dec8e125fb6b",
+        "size_in_bytes": 5758
+      },
+      {
+        "_path": "Lib/__pycache__/aifc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9429837bf9e9dea3d580e2505fac2e5900c80aba32ded7cdb0eabd17ef35055a",
+        "sha256_in_prefix": "9429837bf9e9dea3d580e2505fac2e5900c80aba32ded7cdb0eabd17ef35055a",
+        "size_in_bytes": 25249
+      },
+      {
+        "_path": "Lib/__pycache__/antigravity.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e2ec0a905b36f02068ee3d91cd7f972068a685f76ae77064354ed98c02112427",
+        "sha256_in_prefix": "e2ec0a905b36f02068ee3d91cd7f972068a685f76ae77064354ed98c02112427",
+        "size_in_bytes": 802
+      },
+      {
+        "_path": "Lib/__pycache__/argparse.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6b9e7b8eaa3a3279bf31a7f12f2129e2476dc61acc84df9cd358d32671ff1a37",
+        "sha256_in_prefix": "6b9e7b8eaa3a3279bf31a7f12f2129e2476dc61acc84df9cd358d32671ff1a37",
+        "size_in_bytes": 63637
+      },
+      {
+        "_path": "Lib/__pycache__/ast.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "50272db08754df18e7f4aed1bc960931c50a6a54f345335e9ab028f9cd6ed65a",
+        "sha256_in_prefix": "50272db08754df18e7f4aed1bc960931c50a6a54f345335e9ab028f9cd6ed65a",
+        "size_in_bytes": 52366
+      },
+      {
+        "_path": "Lib/__pycache__/asynchat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0ae0fe60620056573c1f56b325a8b629431ea65d18a0ca7535e897f8b5cf1c65",
+        "sha256_in_prefix": "0ae0fe60620056573c1f56b325a8b629431ea65d18a0ca7535e897f8b5cf1c65",
+        "size_in_bytes": 6805
+      },
+      {
+        "_path": "Lib/__pycache__/asyncore.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aae1465f853081fc2ea75faeef2a0c594f4737020f714b27c7043644323d9e1b",
+        "sha256_in_prefix": "aae1465f853081fc2ea75faeef2a0c594f4737020f714b27c7043644323d9e1b",
+        "size_in_bytes": 16019
+      },
+      {
+        "_path": "Lib/__pycache__/base64.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b0294dbc1104113634134af4bd44b7b29a934cfcff0ddee179f0aa315f0c8cf6",
+        "sha256_in_prefix": "b0294dbc1104113634134af4bd44b7b29a934cfcff0ddee179f0aa315f0c8cf6",
+        "size_in_bytes": 16438
+      },
+      {
+        "_path": "Lib/__pycache__/bdb.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b563d66f38891c85be16ac96672bb2c28accfcbf0d733daed79ebc998ff15841",
+        "sha256_in_prefix": "b563d66f38891c85be16ac96672bb2c28accfcbf0d733daed79ebc998ff15841",
+        "size_in_bytes": 24523
+      },
+      {
+        "_path": "Lib/__pycache__/binhex.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3185c50b97ef841327e23e774708cf2b40bc1d2ed0ea8947078a33ecac939386",
+        "sha256_in_prefix": "3185c50b97ef841327e23e774708cf2b40bc1d2ed0ea8947078a33ecac939386",
+        "size_in_bytes": 12948
+      },
+      {
+        "_path": "Lib/__pycache__/bisect.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b394acfe56a7a291d0ca2d85080d6f01bdb0012f7670e4c468063cf5d353426a",
+        "sha256_in_prefix": "b394acfe56a7a291d0ca2d85080d6f01bdb0012f7670e4c468063cf5d353426a",
+        "size_in_bytes": 2333
+      },
+      {
+        "_path": "Lib/__pycache__/bz2.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1770e16e35f086ee5d37f971ddefab3e0816e07feebff5c696dc711f071558e0",
+        "sha256_in_prefix": "1770e16e35f086ee5d37f971ddefab3e0816e07feebff5c696dc711f071558e0",
+        "size_in_bytes": 11528
+      },
+      {
+        "_path": "Lib/__pycache__/cProfile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fc81ffef6f82b9f1fc0a8872f3b5c85a3c347e1b0a46c41b92462aef426f0c70",
+        "sha256_in_prefix": "fc81ffef6f82b9f1fc0a8872f3b5c85a3c347e1b0a46c41b92462aef426f0c70",
+        "size_in_bytes": 5099
+      },
+      {
+        "_path": "Lib/__pycache__/calendar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3778d847c8938737508993694182506121776072ed7cc5aac9c87d6814f475d2",
+        "sha256_in_prefix": "3778d847c8938737508993694182506121776072ed7cc5aac9c87d6814f475d2",
+        "size_in_bytes": 27014
+      },
+      {
+        "_path": "Lib/__pycache__/cgi.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "242fe4cfa6195920c4cfc79fdcb872186b5ea74e44332b7d97b66b28b29e65f6",
+        "sha256_in_prefix": "242fe4cfa6195920c4cfc79fdcb872186b5ea74e44332b7d97b66b28b29e65f6",
+        "size_in_bytes": 26465
+      },
+      {
+        "_path": "Lib/__pycache__/cgitb.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b187a8abb51fc73c274cd00decae0bfc990b3ca7b2e014beafc74bbc775b4bc1",
+        "sha256_in_prefix": "b187a8abb51fc73c274cd00decae0bfc990b3ca7b2e014beafc74bbc775b4bc1",
+        "size_in_bytes": 10169
+      },
+      {
+        "_path": "Lib/__pycache__/chunk.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1998e6aa38a0a1d18de62c27369c97c06337c00386c06753289c83db47d81669",
+        "sha256_in_prefix": "1998e6aa38a0a1d18de62c27369c97c06337c00386c06753289c83db47d81669",
+        "size_in_bytes": 4824
+      },
+      {
+        "_path": "Lib/__pycache__/cmd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5d671e05ea42d97c57fbf0e8118a2bab598cd8f6f2fed1600a5e66a7c6b8529e",
+        "sha256_in_prefix": "5d671e05ea42d97c57fbf0e8118a2bab598cd8f6f2fed1600a5e66a7c6b8529e",
+        "size_in_bytes": 12659
+      },
+      {
+        "_path": "Lib/__pycache__/code.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ddadcd9f6bc44cceded06bd1e4368c9aed6138d36b020e6c319948cb9ab3b56b",
+        "sha256_in_prefix": "ddadcd9f6bc44cceded06bd1e4368c9aed6138d36b020e6c319948cb9ab3b56b",
+        "size_in_bytes": 9899
+      },
+      {
+        "_path": "Lib/__pycache__/codecs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c70f75a8342f428c1c235432a414bb7b9fa51086161119a305414c51b24f5f5f",
+        "sha256_in_prefix": "c70f75a8342f428c1c235432a414bb7b9fa51086161119a305414c51b24f5f5f",
+        "size_in_bytes": 33871
+      },
+      {
+        "_path": "Lib/__pycache__/codeop.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "837499faf527b4182f20adead8fe448215fca417f75412ee80bef9ae6c4bf1e3",
+        "sha256_in_prefix": "837499faf527b4182f20adead8fe448215fca417f75412ee80bef9ae6c4bf1e3",
+        "size_in_bytes": 6441
+      },
+      {
+        "_path": "Lib/__pycache__/colorsys.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3f5537eeded3ac278e8ed0a29ceda40e0cd232121a6bed4012d838607e1a790f",
+        "sha256_in_prefix": "3f5537eeded3ac278e8ed0a29ceda40e0cd232121a6bed4012d838607e1a790f",
+        "size_in_bytes": 3243
+      },
+      {
+        "_path": "Lib/__pycache__/compileall.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "252c7b019c9dd226c830caead679a0a79365a3fc1590a90435ae5bd077f08fe0",
+        "sha256_in_prefix": "252c7b019c9dd226c830caead679a0a79365a3fc1590a90435ae5bd077f08fe0",
+        "size_in_bytes": 12572
+      },
+      {
+        "_path": "Lib/__pycache__/configparser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "faf972631f8ace0f264af3b55f70b68c1286a67296eac426fb43ce50adb9f12b",
+        "sha256_in_prefix": "faf972631f8ace0f264af3b55f70b68c1286a67296eac426fb43ce50adb9f12b",
+        "size_in_bytes": 45852
+      },
+      {
+        "_path": "Lib/__pycache__/contextlib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "36b9eede20db76ed18b90f065478fd6a4819bbd97e4f7c7710b8bf808a6b1e8e",
+        "sha256_in_prefix": "36b9eede20db76ed18b90f065478fd6a4819bbd97e4f7c7710b8bf808a6b1e8e",
+        "size_in_bytes": 19521
+      },
+      {
+        "_path": "Lib/__pycache__/contextvars.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "814aaf74a049a62bb5a4fd12f1867a90e6ecdb8db2881060bcc2f77cb51c97fe",
+        "sha256_in_prefix": "814aaf74a049a62bb5a4fd12f1867a90e6ecdb8db2881060bcc2f77cb51c97fe",
+        "size_in_bytes": 228
+      },
+      {
+        "_path": "Lib/__pycache__/copy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a547e315e2fb035b98deac187d3e048bac4b420ffb7d3dfb3b9658a531d8f2a0",
+        "sha256_in_prefix": "a547e315e2fb035b98deac187d3e048bac4b420ffb7d3dfb3b9658a531d8f2a0",
+        "size_in_bytes": 6946
+      },
+      {
+        "_path": "Lib/__pycache__/copyreg.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "be3611eb431433897c8583ac959a40d5fd2f0241cfb798c0a3e63650eae3dbe6",
+        "sha256_in_prefix": "be3611eb431433897c8583ac959a40d5fd2f0241cfb798c0a3e63650eae3dbe6",
+        "size_in_bytes": 4413
+      },
+      {
+        "_path": "Lib/__pycache__/crypt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4349e7b2b4184f159b83673766b5b56ed102d83851297959acf5c0621bd720af",
+        "sha256_in_prefix": "4349e7b2b4184f159b83673766b5b56ed102d83851297959acf5c0621bd720af",
+        "size_in_bytes": 3496
+      },
+      {
+        "_path": "Lib/__pycache__/csv.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9dd5197f69a91bcd106169912eccd9f6ea6cd9867fb04dc162d0c6a58f61a0b8",
+        "sha256_in_prefix": "9dd5197f69a91bcd106169912eccd9f6ea6cd9867fb04dc162d0c6a58f61a0b8",
+        "size_in_bytes": 11832
+      },
+      {
+        "_path": "Lib/__pycache__/dataclasses.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "af3c3e76d2399b0a2df1856effb7586bfc174e992268a9e0f693c4e58112982e",
+        "sha256_in_prefix": "af3c3e76d2399b0a2df1856effb7586bfc174e992268a9e0f693c4e58112982e",
+        "size_in_bytes": 23200
+      },
+      {
+        "_path": "Lib/__pycache__/datetime.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b5331b4df6e9fb9d48da48f62ea00285770d2bba3195259a9a277f951a90048d",
+        "sha256_in_prefix": "b5331b4df6e9fb9d48da48f62ea00285770d2bba3195259a9a277f951a90048d",
+        "size_in_bytes": 58098
+      },
+      {
+        "_path": "Lib/__pycache__/decimal.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "46d6b5ed7a3fd14810c6bb64e219e269051e15da3bb32cc3591e75f4213e0ee4",
+        "sha256_in_prefix": "46d6b5ed7a3fd14810c6bb64e219e269051e15da3bb32cc3591e75f4213e0ee4",
+        "size_in_bytes": 342
+      },
+      {
+        "_path": "Lib/__pycache__/difflib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b140ab90af8100555542d7c7ad88919924f4ef72aa2467a3e9eaf62fb5acf3b0",
+        "sha256_in_prefix": "b140ab90af8100555542d7c7ad88919924f4ef72aa2467a3e9eaf62fb5acf3b0",
+        "size_in_bytes": 58563
+      },
+      {
+        "_path": "Lib/__pycache__/dis.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "01f2df05f4485d84d2a05693bb4f6f626b8b49ac18589268ed8830d2f10b6111",
+        "sha256_in_prefix": "01f2df05f4485d84d2a05693bb4f6f626b8b49ac18589268ed8830d2f10b6111",
+        "size_in_bytes": 15803
+      },
+      {
+        "_path": "Lib/__pycache__/doctest.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bf9cde16ee376d896498c63447dd267f2191419edd772c7caf9483e54ae27e38",
+        "sha256_in_prefix": "bf9cde16ee376d896498c63447dd267f2191419edd772c7caf9483e54ae27e38",
+        "size_in_bytes": 76022
+      },
+      {
+        "_path": "Lib/__pycache__/enum.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ee2228e8bf7a0061099664b92ef3fb6c3f9dc8e5752b068475a76df70d11e339",
+        "sha256_in_prefix": "ee2228e8bf7a0061099664b92ef3fb6c3f9dc8e5752b068475a76df70d11e339",
+        "size_in_bytes": 26003
+      },
+      {
+        "_path": "Lib/__pycache__/filecmp.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "811551f46347c8017d179f819433c72c2632faff5a49b28439db1e380350af23",
+        "sha256_in_prefix": "811551f46347c8017d179f819433c72c2632faff5a49b28439db1e380350af23",
+        "size_in_bytes": 8605
+      },
+      {
+        "_path": "Lib/__pycache__/fileinput.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3f009a7a68e558d8a3da68b1b913e26c3fa460812eebcd54e16971f1bb8ce2ac",
+        "sha256_in_prefix": "3f009a7a68e558d8a3da68b1b913e26c3fa460812eebcd54e16971f1bb8ce2ac",
+        "size_in_bytes": 13773
+      },
+      {
+        "_path": "Lib/__pycache__/fnmatch.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b8f460492af3ac63d603c18c44eaa37c6a00b0712bd05337e0da2bbfd0fd92f0",
+        "sha256_in_prefix": "b8f460492af3ac63d603c18c44eaa37c6a00b0712bd05337e0da2bbfd0fd92f0",
+        "size_in_bytes": 3925
+      },
+      {
+        "_path": "Lib/__pycache__/formatter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a197f6046e3283d87ed556a2e127892dfa27d994c85ade32e5675c7211e58e03",
+        "sha256_in_prefix": "a197f6046e3283d87ed556a2e127892dfa27d994c85ade32e5675c7211e58e03",
+        "size_in_bytes": 17522
+      },
+      {
+        "_path": "Lib/__pycache__/fractions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b977bae51679181c525901653712c4c9978f4628abdd64fd39a8beaa140af9a5",
+        "sha256_in_prefix": "b977bae51679181c525901653712c4c9978f4628abdd64fd39a8beaa140af9a5",
+        "size_in_bytes": 18032
+      },
+      {
+        "_path": "Lib/__pycache__/ftplib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a7794749f58559608c394b4887b21e2bc79246f59c05d42099c2c90e0e42d845",
+        "sha256_in_prefix": "a7794749f58559608c394b4887b21e2bc79246f59c05d42099c2c90e0e42d845",
+        "size_in_bytes": 28677
+      },
+      {
+        "_path": "Lib/__pycache__/functools.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "825725d996e3e45663cd000d281197e847518f239e2d2625153e29d389d6bba3",
+        "sha256_in_prefix": "825725d996e3e45663cd000d281197e847518f239e2d2625153e29d389d6bba3",
+        "size_in_bytes": 28706
+      },
+      {
+        "_path": "Lib/__pycache__/genericpath.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b26bc91d44ba799fda7a2fe046800dfb4dbf81a0339fd3debc940b4283ba507a",
+        "sha256_in_prefix": "b26bc91d44ba799fda7a2fe046800dfb4dbf81a0339fd3debc940b4283ba507a",
+        "size_in_bytes": 4007
+      },
+      {
+        "_path": "Lib/__pycache__/getopt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7a510889946208707a76a90c611adf8c804c811dd49ea5a88f080c6f4a91a61c",
+        "sha256_in_prefix": "7a510889946208707a76a90c611adf8c804c811dd49ea5a88f080c6f4a91a61c",
+        "size_in_bytes": 6243
+      },
+      {
+        "_path": "Lib/__pycache__/getpass.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d8c128e75bc6a9ae3290a33ab8538cf4e1c2d3276458ad3d4bf2388f66ed2977",
+        "sha256_in_prefix": "d8c128e75bc6a9ae3290a33ab8538cf4e1c2d3276458ad3d4bf2388f66ed2977",
+        "size_in_bytes": 4183
+      },
+      {
+        "_path": "Lib/__pycache__/gettext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "92c7ce809d3b1a757859b9279eac7547af569f92d9e52c333b630d6fe4281375",
+        "sha256_in_prefix": "92c7ce809d3b1a757859b9279eac7547af569f92d9e52c333b630d6fe4281375",
+        "size_in_bytes": 18056
+      },
+      {
+        "_path": "Lib/__pycache__/glob.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "299636a07a05b71c75158f50a38dcf3c5e4bd02ee815ca83d7d6ca9b1d590bcc",
+        "sha256_in_prefix": "299636a07a05b71c75158f50a38dcf3c5e4bd02ee815ca83d7d6ca9b1d590bcc",
+        "size_in_bytes": 4527
+      },
+      {
+        "_path": "Lib/__pycache__/graphlib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "747737bf8e20904ed2decc295a0d5986098d3c5543cbf2f2897c62777ce0e8d0",
+        "sha256_in_prefix": "747737bf8e20904ed2decc295a0d5986098d3c5543cbf2f2897c62777ce0e8d0",
+        "size_in_bytes": 7551
+      },
+      {
+        "_path": "Lib/__pycache__/gzip.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "09b6d27657ae23798dea148692deeb795d52c485b209bc1d16862af8349f17c8",
+        "sha256_in_prefix": "09b6d27657ae23798dea148692deeb795d52c485b209bc1d16862af8349f17c8",
+        "size_in_bytes": 18477
+      },
+      {
+        "_path": "Lib/__pycache__/hashlib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2ccc2b05f2e6c3ed6f8de26409a663aa0bd98c2f2e75e1eda84eb6c093753b82",
+        "sha256_in_prefix": "2ccc2b05f2e6c3ed6f8de26409a663aa0bd98c2f2e75e1eda84eb6c093753b82",
+        "size_in_bytes": 6674
+      },
+      {
+        "_path": "Lib/__pycache__/heapq.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "66ee4f7c4f99efacacb3a49c7c46ad0c30cd2cfc772b388c242477a700ba0f75",
+        "sha256_in_prefix": "66ee4f7c4f99efacacb3a49c7c46ad0c30cd2cfc772b388c242477a700ba0f75",
+        "size_in_bytes": 14023
+      },
+      {
+        "_path": "Lib/__pycache__/hmac.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0f0222c5b3772fcea4ed129238d48a72f15cbc44c5dfecca283481123aaabdc0",
+        "sha256_in_prefix": "0f0222c5b3772fcea4ed129238d48a72f15cbc44c5dfecca283481123aaabdc0",
+        "size_in_bytes": 6783
+      },
+      {
+        "_path": "Lib/__pycache__/imaplib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "54bf25670bd38076e38eb17f27e2dc8fad1ac711eced1708926c500631a6774d",
+        "sha256_in_prefix": "54bf25670bd38076e38eb17f27e2dc8fad1ac711eced1708926c500631a6774d",
+        "size_in_bytes": 42395
+      },
+      {
+        "_path": "Lib/__pycache__/imghdr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "33f8f56f85ac48c1120b1c95954df512682890970a333e30e9b83c65ecd1e750",
+        "sha256_in_prefix": "33f8f56f85ac48c1120b1c95954df512682890970a333e30e9b83c65ecd1e750",
+        "size_in_bytes": 4123
+      },
+      {
+        "_path": "Lib/__pycache__/imp.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "29191d7957e9bd55c533d37e17be145f923e33a5c6306f6a9a2cedd1bbb6a6ab",
+        "sha256_in_prefix": "29191d7957e9bd55c533d37e17be145f923e33a5c6306f6a9a2cedd1bbb6a6ab",
+        "size_in_bytes": 9834
+      },
+      {
+        "_path": "Lib/__pycache__/inspect.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "69b8518b40e2f51b991499e0d2195003e0660d274f06188851824562209fc090",
+        "sha256_in_prefix": "69b8518b40e2f51b991499e0d2195003e0660d274f06188851824562209fc090",
+        "size_in_bytes": 81455
+      },
+      {
+        "_path": "Lib/__pycache__/io.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2dcfadad5b6b8115cb9c9ca58e366028975a6ecb2de8a329d03faf71641e98f1",
+        "sha256_in_prefix": "2dcfadad5b6b8115cb9c9ca58e366028975a6ecb2de8a329d03faf71641e98f1",
+        "size_in_bytes": 3391
+      },
+      {
+        "_path": "Lib/__pycache__/ipaddress.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fc9a0b228b58c0f4a9219c16b305748eaac981e99389bd7e89da8959d3e80c67",
+        "sha256_in_prefix": "fc9a0b228b58c0f4a9219c16b305748eaac981e99389bd7e89da8959d3e80c67",
+        "size_in_bytes": 64023
+      },
+      {
+        "_path": "Lib/__pycache__/keyword.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fab29ba9010bec8f97dc78d69af2674a7d9a7a046696c62dff1d34ae334797ab",
+        "sha256_in_prefix": "fab29ba9010bec8f97dc78d69af2674a7d9a7a046696c62dff1d34ae334797ab",
+        "size_in_bytes": 899
+      },
+      {
+        "_path": "Lib/__pycache__/linecache.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8b8f13f1191efe070687a2690afa420ea7c4a64f2287c426b99a07572d3264d7",
+        "sha256_in_prefix": "8b8f13f1191efe070687a2690afa420ea7c4a64f2287c426b99a07572d3264d7",
+        "size_in_bytes": 4011
+      },
+      {
+        "_path": "Lib/__pycache__/locale.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8a2adec54db7977672fce3cff3c82e085afece11fbd955c8db7ff9ea5b09904b",
+        "sha256_in_prefix": "8a2adec54db7977672fce3cff3c82e085afece11fbd955c8db7ff9ea5b09904b",
+        "size_in_bytes": 34679
+      },
+      {
+        "_path": "Lib/__pycache__/lzma.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "36a148ca74d05f66adf762cbd98a968a51f343d08e38b1694777e9416653431c",
+        "sha256_in_prefix": "36a148ca74d05f66adf762cbd98a968a51f343d08e38b1694777e9416653431c",
+        "size_in_bytes": 12077
+      },
+      {
+        "_path": "Lib/__pycache__/mailbox.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ed112ebd17cce11c31342f4dab5bcff9403bfe71f679804333bebdf67a482b64",
+        "sha256_in_prefix": "ed112ebd17cce11c31342f4dab5bcff9403bfe71f679804333bebdf67a482b64",
+        "size_in_bytes": 60583
+      },
+      {
+        "_path": "Lib/__pycache__/mailcap.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dad6aa1828b43a6e08dd4e9e3dfbc6b82c01e6145301cc6604de52aff0a28dab",
+        "sha256_in_prefix": "dad6aa1828b43a6e08dd4e9e3dfbc6b82c01e6145301cc6604de52aff0a28dab",
+        "size_in_bytes": 7222
+      },
+      {
+        "_path": "Lib/__pycache__/mimetypes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "97a3f3b4ac90ad1b8c3a33463a6d8c1addd0715d337d22540adc19a6ce72ab11",
+        "sha256_in_prefix": "97a3f3b4ac90ad1b8c3a33463a6d8c1addd0715d337d22540adc19a6ce72ab11",
+        "size_in_bytes": 15998
+      },
+      {
+        "_path": "Lib/__pycache__/modulefinder.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "804a08e66dfded939385e491e0db4dce39a615b4a90c5822747201fc8cfac0d1",
+        "sha256_in_prefix": "804a08e66dfded939385e491e0db4dce39a615b4a90c5822747201fc8cfac0d1",
+        "size_in_bytes": 16111
+      },
+      {
+        "_path": "Lib/__pycache__/netrc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cba56ad17667e0104ef334b3ceef3caa73edb1c1f8eeefc918fdd6430764ea14",
+        "sha256_in_prefix": "cba56ad17667e0104ef334b3ceef3caa73edb1c1f8eeefc918fdd6430764ea14",
+        "size_in_bytes": 3766
+      },
+      {
+        "_path": "Lib/__pycache__/nntplib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b70c77048aa4e2b651070d27fd0c3ebab27e096238b001f322af05d47dd0584d",
+        "sha256_in_prefix": "b70c77048aa4e2b651070d27fd0c3ebab27e096238b001f322af05d47dd0584d",
+        "size_in_bytes": 31746
+      },
+      {
+        "_path": "Lib/__pycache__/ntpath.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ea92c40382f679ae9c4a4042708efb5d43c0cebdcdb37c7305b40e9d44bfbe90",
+        "sha256_in_prefix": "ea92c40382f679ae9c4a4042708efb5d43c0cebdcdb37c7305b40e9d44bfbe90",
+        "size_in_bytes": 14525
+      },
+      {
+        "_path": "Lib/__pycache__/nturl2path.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9b91cc4de6872cbca9b22098391e520ab3c2941ba4330fa12f264689ef54780b",
+        "sha256_in_prefix": "9b91cc4de6872cbca9b22098391e520ab3c2941ba4330fa12f264689ef54780b",
+        "size_in_bytes": 1729
+      },
+      {
+        "_path": "Lib/__pycache__/numbers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "976950162475670e3f6e2813c1422424645f92ea4521658c2321983c9f23fb55",
+        "sha256_in_prefix": "976950162475670e3f6e2813c1422424645f92ea4521658c2321983c9f23fb55",
+        "size_in_bytes": 12302
+      },
+      {
+        "_path": "Lib/__pycache__/opcode.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f9d6a5028256d8279a74d019a8277f66b55a3878b723b66faafa011b52fc3523",
+        "sha256_in_prefix": "f9d6a5028256d8279a74d019a8277f66b55a3878b723b66faafa011b52fc3523",
+        "size_in_bytes": 5206
+      },
+      {
+        "_path": "Lib/__pycache__/operator.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6071922a469c55816e23e27cc59bfe8293af7e6204ab0558f79489d2a248bb08",
+        "sha256_in_prefix": "6071922a469c55816e23e27cc59bfe8293af7e6204ab0558f79489d2a248bb08",
+        "size_in_bytes": 13767
+      },
+      {
+        "_path": "Lib/__pycache__/optparse.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "515f92fd19963cfd9a454b02239b1bd91a0c05dc81a368d8cdc6271a80a13f40",
+        "sha256_in_prefix": "515f92fd19963cfd9a454b02239b1bd91a0c05dc81a368d8cdc6271a80a13f40",
+        "size_in_bytes": 47926
+      },
+      {
+        "_path": "Lib/__pycache__/os.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c0a130c6e1142bcf372373c2710628c46548186ac42798c79a90f4f6356ae2e8",
+        "sha256_in_prefix": "c0a130c6e1142bcf372373c2710628c46548186ac42798c79a90f4f6356ae2e8",
+        "size_in_bytes": 31629
+      },
+      {
+        "_path": "Lib/__pycache__/pathlib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bda74294332d3e661406e316b6868d380a79de7a4733c0b1e4944b01f2a31759",
+        "sha256_in_prefix": "bda74294332d3e661406e316b6868d380a79de7a4733c0b1e4944b01f2a31759",
+        "size_in_bytes": 44708
+      },
+      {
+        "_path": "Lib/__pycache__/pdb.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "abfd89b8721519dec9addf1499533e4214f1e460e9bba708e99aca223288f508",
+        "sha256_in_prefix": "abfd89b8721519dec9addf1499533e4214f1e460e9bba708e99aca223288f508",
+        "size_in_bytes": 47569
+      },
+      {
+        "_path": "Lib/__pycache__/pickle.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b71906ef2bc46fa8ba124b2638a692ff003ee63a3a403048bc5cca8ea7380750",
+        "sha256_in_prefix": "b71906ef2bc46fa8ba124b2638a692ff003ee63a3a403048bc5cca8ea7380750",
+        "size_in_bytes": 47081
+      },
+      {
+        "_path": "Lib/__pycache__/pickletools.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4658176a52c7aa78b1fb58f2f3b96033d473bea43442f9cabebb4b5fe26f2c39",
+        "sha256_in_prefix": "4658176a52c7aa78b1fb58f2f3b96033d473bea43442f9cabebb4b5fe26f2c39",
+        "size_in_bytes": 67090
+      },
+      {
+        "_path": "Lib/__pycache__/pipes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "996c4bcf88b9b120c4b39d9996ad35adc81366cde7471821cae7f9990fdb294c",
+        "sha256_in_prefix": "996c4bcf88b9b120c4b39d9996ad35adc81366cde7471821cae7f9990fdb294c",
+        "size_in_bytes": 7778
+      },
+      {
+        "_path": "Lib/__pycache__/pkgutil.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c36716a4e1fa6c9292f25264847df5f0e1db0b89c9b84678f3047d984c844ebe",
+        "sha256_in_prefix": "c36716a4e1fa6c9292f25264847df5f0e1db0b89c9b84678f3047d984c844ebe",
+        "size_in_bytes": 18549
+      },
+      {
+        "_path": "Lib/__pycache__/platform.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "88e462062c0986aed9b1f77f2c7959159b32943b53e7810de20958aeb43a3e88",
+        "sha256_in_prefix": "88e462062c0986aed9b1f77f2c7959159b32943b53e7810de20958aeb43a3e88",
+        "size_in_bytes": 26463
+      },
+      {
+        "_path": "Lib/__pycache__/plistlib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "07eb81d291f90b9a2aeb715956406279ac46a236a901ad664eb1a04370e376b0",
+        "sha256_in_prefix": "07eb81d291f90b9a2aeb715956406279ac46a236a901ad664eb1a04370e376b0",
+        "size_in_bytes": 23530
+      },
+      {
+        "_path": "Lib/__pycache__/poplib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3a65761ac86c381fd63f5b5e09b74c0700220140c05906eb2a86eeb0b57fbd4c",
+        "sha256_in_prefix": "3a65761ac86c381fd63f5b5e09b74c0700220140c05906eb2a86eeb0b57fbd4c",
+        "size_in_bytes": 13640
+      },
+      {
+        "_path": "Lib/__pycache__/posixpath.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "73dd7fb6dd585409d9a1965ddb83c11bbef9682487af1da7be516dc899a8bbfe",
+        "sha256_in_prefix": "73dd7fb6dd585409d9a1965ddb83c11bbef9682487af1da7be516dc899a8bbfe",
+        "size_in_bytes": 10312
+      },
+      {
+        "_path": "Lib/__pycache__/pprint.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d72327c3ea20551f86173318c049ccef2506c25bfde2cedd8c0ee6348367d26",
+        "sha256_in_prefix": "2d72327c3ea20551f86173318c049ccef2506c25bfde2cedd8c0ee6348367d26",
+        "size_in_bytes": 16813
+      },
+      {
+        "_path": "Lib/__pycache__/profile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "503a4c2bf158265260917cbab99531a8d95791f340c97535258f5bf8912a38e4",
+        "sha256_in_prefix": "503a4c2bf158265260917cbab99531a8d95791f340c97535258f5bf8912a38e4",
+        "size_in_bytes": 14394
+      },
+      {
+        "_path": "Lib/__pycache__/pstats.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ab1da57d232a2fbac3281e8da7ff8f2e43a32bb19470148b5c71b5af00411983",
+        "sha256_in_prefix": "ab1da57d232a2fbac3281e8da7ff8f2e43a32bb19470148b5c71b5af00411983",
+        "size_in_bytes": 23735
+      },
+      {
+        "_path": "Lib/__pycache__/pty.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "af834304975bf620092801b54746edd2704dcbd3a7d148f2b16fb3f2bef5d17b",
+        "sha256_in_prefix": "af834304975bf620092801b54746edd2704dcbd3a7d148f2b16fb3f2bef5d17b",
+        "size_in_bytes": 3939
+      },
+      {
+        "_path": "Lib/__pycache__/py_compile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8217a70341783ed297010290ed423898b77fe9e34b51d00c50349a18e04eb580",
+        "sha256_in_prefix": "8217a70341783ed297010290ed423898b77fe9e34b51d00c50349a18e04eb580",
+        "size_in_bytes": 7347
+      },
+      {
+        "_path": "Lib/__pycache__/pyclbr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bbf5e7b041ae67d1541430ab05134af3dca69bc4e1bffe562b030d395f09ea5b",
+        "sha256_in_prefix": "bbf5e7b041ae67d1541430ab05134af3dca69bc4e1bffe562b030d395f09ea5b",
+        "size_in_bytes": 10432
+      },
+      {
+        "_path": "Lib/__pycache__/pydoc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c8aa0349bb1c3898068a8eb32e83b838872b5f17c10071ebf136cd3011ed1e74",
+        "sha256_in_prefix": "c8aa0349bb1c3898068a8eb32e83b838872b5f17c10071ebf136cd3011ed1e74",
+        "size_in_bytes": 85443
+      },
+      {
+        "_path": "Lib/__pycache__/queue.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cb5797db3a13853964f8252c4b003e91c8b3ccbae7de6820e8d0fa393166d198",
+        "sha256_in_prefix": "cb5797db3a13853964f8252c4b003e91c8b3ccbae7de6820e8d0fa393166d198",
+        "size_in_bytes": 10859
+      },
+      {
+        "_path": "Lib/__pycache__/quopri.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8c08c7ea9955b7150f2d564b72a884fa8758676cde047086cea59dff015d8ea3",
+        "sha256_in_prefix": "8c08c7ea9955b7150f2d564b72a884fa8758676cde047086cea59dff015d8ea3",
+        "size_in_bytes": 5730
+      },
+      {
+        "_path": "Lib/__pycache__/random.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8285687fadb154471da65280127137133e5d4d53d5c2fb305b7f763c510b3e90",
+        "sha256_in_prefix": "8285687fadb154471da65280127137133e5d4d53d5c2fb305b7f763c510b3e90",
+        "size_in_bytes": 22026
+      },
+      {
+        "_path": "Lib/__pycache__/re.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "52ee91a53c62760825272c685607b8b9934751bd7e026ec1c08373dadf8f0060",
+        "sha256_in_prefix": "52ee91a53c62760825272c685607b8b9934751bd7e026ec1c08373dadf8f0060",
+        "size_in_bytes": 14345
+      },
+      {
+        "_path": "Lib/__pycache__/reprlib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "484f72a573a41bd48bf57387b3fa1cb042273a72a89c51a760d4d3fdb810d457",
+        "sha256_in_prefix": "484f72a573a41bd48bf57387b3fa1cb042273a72a89c51a760d4d3fdb810d457",
+        "size_in_bytes": 5290
+      },
+      {
+        "_path": "Lib/__pycache__/rlcompleter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b96597ae604c1a13246f67568ce58b9f657d3b23f7cc1389746396d69fd61b0c",
+        "sha256_in_prefix": "b96597ae604c1a13246f67568ce58b9f657d3b23f7cc1389746396d69fd61b0c",
+        "size_in_bytes": 5789
+      },
+      {
+        "_path": "Lib/__pycache__/runpy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2dd87275b318426eeb4a8553e5656bc8e8a1aeec0a3664f219307301d82009c6",
+        "sha256_in_prefix": "2dd87275b318426eeb4a8553e5656bc8e8a1aeec0a3664f219307301d82009c6",
+        "size_in_bytes": 9368
+      },
+      {
+        "_path": "Lib/__pycache__/sched.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a5b8ec27cbdb2ab524ae62108c319c63f987e747b5d3ea679edeb804b9347e8e",
+        "sha256_in_prefix": "a5b8ec27cbdb2ab524ae62108c319c63f987e747b5d3ea679edeb804b9347e8e",
+        "size_in_bytes": 6616
+      },
+      {
+        "_path": "Lib/__pycache__/secrets.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5b25a68360a457440846cb57e07572b0a4a68fa57708ec90b5028a901af6b963",
+        "sha256_in_prefix": "5b25a68360a457440846cb57e07572b0a4a68fa57708ec90b5028a901af6b963",
+        "size_in_bytes": 2163
+      },
+      {
+        "_path": "Lib/__pycache__/selectors.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "603b0b533c13a66be9cd628fd39100d836cd9b4606bcd61c82235e98c0f0c602",
+        "sha256_in_prefix": "603b0b533c13a66be9cd628fd39100d836cd9b4606bcd61c82235e98c0f0c602",
+        "size_in_bytes": 17228
+      },
+      {
+        "_path": "Lib/__pycache__/shelve.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "429122a07c22b436afee6fc9226c56d05d40ab2cd69045f2684cf3c2f84cfece",
+        "sha256_in_prefix": "429122a07c22b436afee6fc9226c56d05d40ab2cd69045f2684cf3c2f84cfece",
+        "size_in_bytes": 9527
+      },
+      {
+        "_path": "Lib/__pycache__/shlex.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "77303631ccc22e0fe649887df610e7710e8c1d8d6101b12409b3a1ea55e75146",
+        "sha256_in_prefix": "77303631ccc22e0fe649887df610e7710e8c1d8d6101b12409b3a1ea55e75146",
+        "size_in_bytes": 7717
+      },
+      {
+        "_path": "Lib/__pycache__/shutil.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "85462ee0bb35c0e44c97c16a99bd5f62c5021563be0d76b308bde47d96ffb404",
+        "sha256_in_prefix": "85462ee0bb35c0e44c97c16a99bd5f62c5021563be0d76b308bde47d96ffb404",
+        "size_in_bytes": 38480
+      },
+      {
+        "_path": "Lib/__pycache__/signal.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "26b35b700b91eb5d2c747f0b8a2611f81acba2848df6df6b79fa721005b6ac5b",
+        "sha256_in_prefix": "26b35b700b91eb5d2c747f0b8a2611f81acba2848df6df6b79fa721005b6ac5b",
+        "size_in_bytes": 2989
+      },
+      {
+        "_path": "Lib/__pycache__/site.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "143d5e188556ffa3b2e917b718b42b40e9b32a3b9c61480192e7b1e646f14d4a",
+        "sha256_in_prefix": "143d5e188556ffa3b2e917b718b42b40e9b32a3b9c61480192e7b1e646f14d4a",
+        "size_in_bytes": 16993
+      },
+      {
+        "_path": "Lib/__pycache__/smtpd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5535dbd48405e74a7823502153619c5881231a06e8c59554985fba53a6d6e36d",
+        "sha256_in_prefix": "5535dbd48405e74a7823502153619c5881231a06e8c59554985fba53a6d6e36d",
+        "size_in_bytes": 26507
+      },
+      {
+        "_path": "Lib/__pycache__/smtplib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8a06f600f0a3f27ccdda4ee8b661b8fc5285a8c6a63f4b911e73116cf170250c",
+        "sha256_in_prefix": "8a06f600f0a3f27ccdda4ee8b661b8fc5285a8c6a63f4b911e73116cf170250c",
+        "size_in_bytes": 35913
+      },
+      {
+        "_path": "Lib/__pycache__/sndhdr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9939d787519254286715aa24576eac341912a3fad8cf99540966102ae9739890",
+        "sha256_in_prefix": "9939d787519254286715aa24576eac341912a3fad8cf99540966102ae9739890",
+        "size_in_bytes": 6976
+      },
+      {
+        "_path": "Lib/__pycache__/socket.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9b190bdde813db07217bbe58319d468fcbd0b79d6d46fda014ae64e97474c598",
+        "sha256_in_prefix": "9b190bdde813db07217bbe58319d468fcbd0b79d6d46fda014ae64e97474c598",
+        "size_in_bytes": 28983
+      },
+      {
+        "_path": "Lib/__pycache__/socketserver.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "35a0b19008894a4408444acfb5a3650c5f89a3a65e1241cd0d72787c9d9e5d33",
+        "sha256_in_prefix": "35a0b19008894a4408444acfb5a3650c5f89a3a65e1241cd0d72787c9d9e5d33",
+        "size_in_bytes": 25498
+      },
+      {
+        "_path": "Lib/__pycache__/sre_compile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ebca90ad57b991bbd9b619616885052233fbc45042c89d3d4647750e3d9eeee6",
+        "sha256_in_prefix": "ebca90ad57b991bbd9b619616885052233fbc45042c89d3d4647750e3d9eeee6",
+        "size_in_bytes": 15137
+      },
+      {
+        "_path": "Lib/__pycache__/sre_constants.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6b5d27f41963db44b6a3c7811ddde3423f34a1808e4bcd677d818f635badb43a",
+        "sha256_in_prefix": "6b5d27f41963db44b6a3c7811ddde3423f34a1808e4bcd677d818f635badb43a",
+        "size_in_bytes": 6319
+      },
+      {
+        "_path": "Lib/__pycache__/sre_parse.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a88ff2e7b81ce2e1c9fbddb926e1cf56894ac8eda4ab3c364ef0e546c1f274fb",
+        "sha256_in_prefix": "a88ff2e7b81ce2e1c9fbddb926e1cf56894ac8eda4ab3c364ef0e546c1f274fb",
+        "size_in_bytes": 21792
+      },
+      {
+        "_path": "Lib/__pycache__/ssl.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "346ac3ac6b01f96e80bcbcab91cc210b6b60b09e74192ad7ec2d247e5f9ec0c4",
+        "sha256_in_prefix": "346ac3ac6b01f96e80bcbcab91cc210b6b60b09e74192ad7ec2d247e5f9ec0c4",
+        "size_in_bytes": 45040
+      },
+      {
+        "_path": "Lib/__pycache__/stat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9c8f664b5c6cf2b1420cf2310fc0730514a23aa962b95a17fc9138e4ac4794da",
+        "sha256_in_prefix": "9c8f664b5c6cf2b1420cf2310fc0730514a23aa962b95a17fc9138e4ac4794da",
+        "size_in_bytes": 4355
+      },
+      {
+        "_path": "Lib/__pycache__/statistics.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5a5315ca0e61ef39d42225028ef7f3da6f9b0726905fabe87986013cf53f470f",
+        "sha256_in_prefix": "5a5315ca0e61ef39d42225028ef7f3da6f9b0726905fabe87986013cf53f470f",
+        "size_in_bytes": 31961
+      },
+      {
+        "_path": "Lib/__pycache__/string.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5afcf368cf646180388f19667634391a3fc5c76700875367dee07b78cfa444e0",
+        "sha256_in_prefix": "5afcf368cf646180388f19667634391a3fc5c76700875367dee07b78cfa444e0",
+        "size_in_bytes": 7148
+      },
+      {
+        "_path": "Lib/__pycache__/stringprep.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7781d316df7cacd23b355ab506e2050eb07eb07b5967a0888c712d1ce74be9d8",
+        "sha256_in_prefix": "7781d316df7cacd23b355ab506e2050eb07eb07b5967a0888c712d1ce74be9d8",
+        "size_in_bytes": 9969
+      },
+      {
+        "_path": "Lib/__pycache__/struct.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c3bc7b0b0fe0e2b6afa5b293afc33b84dfe78db253d136450da0f6ca1283fed9",
+        "sha256_in_prefix": "c3bc7b0b0fe0e2b6afa5b293afc33b84dfe78db253d136450da0f6ca1283fed9",
+        "size_in_bytes": 289
+      },
+      {
+        "_path": "Lib/__pycache__/subprocess.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1014a4013dab3d160e7baa87daaa3d45f6360568f0e0dc701e09b0e525ed3186",
+        "sha256_in_prefix": "1014a4013dab3d160e7baa87daaa3d45f6360568f0e0dc701e09b0e525ed3186",
+        "size_in_bytes": 44369
+      },
+      {
+        "_path": "Lib/__pycache__/sunau.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0cd7b5ce672a312051aca492dc7289bbd699d7d506c40bf4035ff70cb04b5ee6",
+        "sha256_in_prefix": "0cd7b5ce672a312051aca492dc7289bbd699d7d506c40bf4035ff70cb04b5ee6",
+        "size_in_bytes": 16800
+      },
+      {
+        "_path": "Lib/__pycache__/symbol.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a49e3c249fe7783569671c08f8b2479bc02c6c6f12436de30bb36fb59195f0d0",
+        "sha256_in_prefix": "a49e3c249fe7783569671c08f8b2479bc02c6c6f12436de30bb36fb59195f0d0",
+        "size_in_bytes": 2562
+      },
+      {
+        "_path": "Lib/__pycache__/symtable.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d190f6a7274cedf9096c95fa4b44eb78581d9641fb458fdda7057d5a871d083a",
+        "sha256_in_prefix": "d190f6a7274cedf9096c95fa4b44eb78581d9641fb458fdda7057d5a871d083a",
+        "size_in_bytes": 11149
+      },
+      {
+        "_path": "Lib/__pycache__/sysconfig.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "81f0eb6df3bb60eb949f242176749612be23a7a1c14ab1b2f0b7bb484267c271",
+        "sha256_in_prefix": "81f0eb6df3bb60eb949f242176749612be23a7a1c14ab1b2f0b7bb484267c271",
+        "size_in_bytes": 16296
+      },
+      {
+        "_path": "Lib/__pycache__/tabnanny.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4de4d5deff3b8aa63ff34d3c5bc98284343c933fda56a3f6745cafd98da4792d",
+        "sha256_in_prefix": "4de4d5deff3b8aa63ff34d3c5bc98284343c933fda56a3f6745cafd98da4792d",
+        "size_in_bytes": 7048
+      },
+      {
+        "_path": "Lib/__pycache__/tarfile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d05a39a3b915803d2bbe5a84d25b22a362e235b5d0a6120623d5b1ff2c695aa8",
+        "sha256_in_prefix": "d05a39a3b915803d2bbe5a84d25b22a362e235b5d0a6120623d5b1ff2c695aa8",
+        "size_in_bytes": 70573
+      },
+      {
+        "_path": "Lib/__pycache__/telnetlib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c64d633954ab64d200cf5672f4ca25816f03228b34f1c4d3bcb52bccfed146bb",
+        "sha256_in_prefix": "c64d633954ab64d200cf5672f4ca25816f03228b34f1c4d3bcb52bccfed146bb",
+        "size_in_bytes": 18314
+      },
+      {
+        "_path": "Lib/__pycache__/tempfile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6f8387ae630155bf3bca2121fbd91d1b13420b2528d3a0f66b43bf096aae4f00",
+        "sha256_in_prefix": "6f8387ae630155bf3bca2121fbd91d1b13420b2528d3a0f66b43bf096aae4f00",
+        "size_in_bytes": 23639
+      },
+      {
+        "_path": "Lib/__pycache__/textwrap.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b87322bdaa8680852c8280cac2b528a2515a8cfcfd609744ad0db4838b23475a",
+        "sha256_in_prefix": "b87322bdaa8680852c8280cac2b528a2515a8cfcfd609744ad0db4838b23475a",
+        "size_in_bytes": 13504
+      },
+      {
+        "_path": "Lib/__pycache__/this.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ff2ba1f5fc46e7c4957cfd3328299dabce519727e6d0f289e7291e7d4e8dd788",
+        "sha256_in_prefix": "ff2ba1f5fc46e7c4957cfd3328299dabce519727e6d0f289e7291e7d4e8dd788",
+        "size_in_bytes": 1242
+      },
+      {
+        "_path": "Lib/__pycache__/threading.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "87167bdc127a88ec191d67c5fe81a7c3e70656d7573c8243837aee1e23ace831",
+        "sha256_in_prefix": "87167bdc127a88ec191d67c5fe81a7c3e70656d7573c8243837aee1e23ace831",
+        "size_in_bytes": 42164
+      },
+      {
+        "_path": "Lib/__pycache__/timeit.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a233f57f82521b4d1d3ab6eaf29461833d01a9940958d0beb93e51ace421973e",
+        "sha256_in_prefix": "a233f57f82521b4d1d3ab6eaf29461833d01a9940958d0beb93e51ace421973e",
+        "size_in_bytes": 11739
+      },
+      {
+        "_path": "Lib/__pycache__/token.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f5ae998a32986c5300ed3be10309a03e026062ef4fefbdc3be4ceb3c3cabaebf",
+        "sha256_in_prefix": "f5ae998a32986c5300ed3be10309a03e026062ef4fefbdc3be4ceb3c3cabaebf",
+        "size_in_bytes": 2479
+      },
+      {
+        "_path": "Lib/__pycache__/tokenize.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ab97edb683ae0bb0c69d7f96b554a1acb750a1f93b79154b22bcadaa458fa736",
+        "sha256_in_prefix": "ab97edb683ae0bb0c69d7f96b554a1acb750a1f93b79154b22bcadaa458fa736",
+        "size_in_bytes": 17148
+      },
+      {
+        "_path": "Lib/__pycache__/trace.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ea91bdd187206271d78ab4150e9e3b83e2f8d1f78a2ea1ee962f13b394e1a7b1",
+        "sha256_in_prefix": "ea91bdd187206271d78ab4150e9e3b83e2f8d1f78a2ea1ee962f13b394e1a7b1",
+        "size_in_bytes": 19742
+      },
+      {
+        "_path": "Lib/__pycache__/traceback.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a3c453a8ddb960170afe4dbcbc89961a59da85cc8a005fd5b9d3f9ba02dd9ee2",
+        "sha256_in_prefix": "a3c453a8ddb960170afe4dbcbc89961a59da85cc8a005fd5b9d3f9ba02dd9ee2",
+        "size_in_bytes": 20423
+      },
+      {
+        "_path": "Lib/__pycache__/tracemalloc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c60fbf65317def68a5a5e0f21cf0917e66acb0e289f6b27fb01159fced57a894",
+        "sha256_in_prefix": "c60fbf65317def68a5a5e0f21cf0917e66acb0e289f6b27fb01159fced57a894",
+        "size_in_bytes": 17918
+      },
+      {
+        "_path": "Lib/__pycache__/tty.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e947a4c0422d00af7082fc0b97503b092feb7f7ba47ba458ef3ef64d47511a5e",
+        "sha256_in_prefix": "e947a4c0422d00af7082fc0b97503b092feb7f7ba47ba458ef3ef64d47511a5e",
+        "size_in_bytes": 1061
+      },
+      {
+        "_path": "Lib/__pycache__/turtle.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f797a930dcfbe9d85f60d8f7a59d1b699948f7352e1f02464fe31171ea150f19",
+        "sha256_in_prefix": "f797a930dcfbe9d85f60d8f7a59d1b699948f7352e1f02464fe31171ea150f19",
+        "size_in_bytes": 129598
+      },
+      {
+        "_path": "Lib/__pycache__/types.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "78df2f443559d4c2f4d4b25ac5e5ec25ed8ad49631f53b8744add93535a40fad",
+        "sha256_in_prefix": "78df2f443559d4c2f4d4b25ac5e5ec25ed8ad49631f53b8744add93535a40fad",
+        "size_in_bytes": 9219
+      },
+      {
+        "_path": "Lib/__pycache__/typing.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d57f0386d3dafe2767d112ef9ae47beab3ec47194ac77b771b7cb034b07b5126",
+        "sha256_in_prefix": "d57f0386d3dafe2767d112ef9ae47beab3ec47194ac77b771b7cb034b07b5126",
+        "size_in_bytes": 71918
+      },
+      {
+        "_path": "Lib/__pycache__/uu.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bc25f6d65e84359055758bb536f934003998ebb6a175bbe522a62c941b596cc0",
+        "sha256_in_prefix": "bc25f6d65e84359055758bb536f934003998ebb6a175bbe522a62c941b596cc0",
+        "size_in_bytes": 3830
+      },
+      {
+        "_path": "Lib/__pycache__/uuid.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bd0a0248fd5e92bc2f04931f71b4e4078b2b14334cd89bcf66040813497bd494",
+        "sha256_in_prefix": "bd0a0248fd5e92bc2f04931f71b4e4078b2b14334cd89bcf66040813497bd494",
+        "size_in_bytes": 22493
+      },
+      {
+        "_path": "Lib/__pycache__/warnings.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b4374bed8665b4e3eda8191b428c7abd72f2650bd60651fbba94decad440163e",
+        "sha256_in_prefix": "b4374bed8665b4e3eda8191b428c7abd72f2650bd60651fbba94decad440163e",
+        "size_in_bytes": 13588
+      },
+      {
+        "_path": "Lib/__pycache__/wave.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "898fd272ccaf5ad9c7626ee3a435b7ad0891fbba29b037e506f72b9f33e2ffda",
+        "sha256_in_prefix": "898fd272ccaf5ad9c7626ee3a435b7ad0891fbba29b037e506f72b9f33e2ffda",
+        "size_in_bytes": 17856
+      },
+      {
+        "_path": "Lib/__pycache__/weakref.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8422478749ee4476224e100ebd2be654e197d1935b43314f3ad2863db7b86964",
+        "sha256_in_prefix": "8422478749ee4476224e100ebd2be654e197d1935b43314f3ad2863db7b86964",
+        "size_in_bytes": 20268
+      },
+      {
+        "_path": "Lib/__pycache__/webbrowser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b8066608208af309da5d2ac5dec598bcf04d663bbc306915ca2cf9b00dc8ed56",
+        "sha256_in_prefix": "b8066608208af309da5d2ac5dec598bcf04d663bbc306915ca2cf9b00dc8ed56",
+        "size_in_bytes": 17117
+      },
+      {
+        "_path": "Lib/__pycache__/xdrlib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f50b19e7453f2e98870bd42c42ad433003961dfa31de6147611561be56934061",
+        "sha256_in_prefix": "f50b19e7453f2e98870bd42c42ad433003961dfa31de6147611561be56934061",
+        "size_in_bytes": 8226
+      },
+      {
+        "_path": "Lib/__pycache__/zipapp.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "086e82edfb43b500096827266fc6cbeabf12495c31e39fd539aaed016e60f64b",
+        "sha256_in_prefix": "086e82edfb43b500096827266fc6cbeabf12495c31e39fd539aaed016e60f64b",
+        "size_in_bytes": 5968
+      },
+      {
+        "_path": "Lib/__pycache__/zipfile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "abbc3e1fc924d4971579b0649fd49a27cda1f1192096f09dae705fab0f42e565",
+        "sha256_in_prefix": "abbc3e1fc924d4971579b0649fd49a27cda1f1192096f09dae705fab0f42e565",
+        "size_in_bytes": 59554
+      },
+      {
+        "_path": "Lib/__pycache__/zipimport.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "17286b972c0934064d926918c8c2d8aee378c4ab9b542b35b17155c24cf2e2ed",
+        "sha256_in_prefix": "17286b972c0934064d926918c8c2d8aee378c4ab9b542b35b17155c24cf2e2ed",
+        "size_in_bytes": 17256
+      },
+      {
+        "_path": "Lib/_aix_support.py",
+        "path_type": "hardlink",
+        "sha256": "177ddfe4bb4d1d74ec6753c631c7d04c1a9badd23420f389d5684a9182fb1067",
+        "sha256_in_prefix": "177ddfe4bb4d1d74ec6753c631c7d04c1a9badd23420f389d5684a9182fb1067",
+        "size_in_bytes": 3389
+      },
+      {
+        "_path": "Lib/_bootlocale.py",
+        "path_type": "hardlink",
+        "sha256": "864f1172268fbc54a6e8ed66ba1158cae8c1707517ff36c1734a97bb3d0e7f21",
+        "sha256_in_prefix": "864f1172268fbc54a6e8ed66ba1158cae8c1707517ff36c1734a97bb3d0e7f21",
+        "size_in_bytes": 1801
+      },
+      {
+        "_path": "Lib/_bootsubprocess.py",
+        "path_type": "hardlink",
+        "sha256": "dd8afc4a86131491a4f05078b307aae5eef19d6a26e7d9ffbfe2ebabbd6b5b6a",
+        "sha256_in_prefix": "dd8afc4a86131491a4f05078b307aae5eef19d6a26e7d9ffbfe2ebabbd6b5b6a",
+        "size_in_bytes": 2675
+      },
+      {
+        "_path": "Lib/_collections_abc.py",
+        "path_type": "hardlink",
+        "sha256": "8a90b2cd9e24d56e2820a1276b41b47ea8dd4a06ba1ed0e3aee39f639be474fc",
+        "sha256_in_prefix": "8a90b2cd9e24d56e2820a1276b41b47ea8dd4a06ba1ed0e3aee39f639be474fc",
+        "size_in_bytes": 29374
+      },
+      {
+        "_path": "Lib/_compat_pickle.py",
+        "path_type": "hardlink",
+        "sha256": "71248216fb1cc2b9a0a1faa305daa8c680d9c637141cb2db283e407684209cab",
+        "sha256_in_prefix": "71248216fb1cc2b9a0a1faa305daa8c680d9c637141cb2db283e407684209cab",
+        "size_in_bytes": 8749
+      },
+      {
+        "_path": "Lib/_compression.py",
+        "path_type": "hardlink",
+        "sha256": "326755377c7b8d98cf71333d62e5b4cb1c4e06519d704961da025f5933dee08d",
+        "sha256_in_prefix": "326755377c7b8d98cf71333d62e5b4cb1c4e06519d704961da025f5933dee08d",
+        "size_in_bytes": 5340
+      },
+      {
+        "_path": "Lib/_markupbase.py",
+        "path_type": "hardlink",
+        "sha256": "80d56ea1d1f7072505459c9f61b81fc25af473a040f3b09d18a15400b13a6a7a",
+        "sha256_in_prefix": "80d56ea1d1f7072505459c9f61b81fc25af473a040f3b09d18a15400b13a6a7a",
+        "size_in_bytes": 14623
+      },
+      {
+        "_path": "Lib/_osx_support.py",
+        "path_type": "hardlink",
+        "sha256": "ee418ad122e3bb12d1050c8e267a5963a38b51d03915a808145d59b67fb17488",
+        "sha256_in_prefix": "ee418ad122e3bb12d1050c8e267a5963a38b51d03915a808145d59b67fb17488",
+        "size_in_bytes": 21773
+      },
+      {
+        "_path": "Lib/_py_abc.py",
+        "path_type": "hardlink",
+        "sha256": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92",
+        "sha256_in_prefix": "f9c6fe3dd9b51bd7d93f867356e9d362600c924febfd903ee1c6e298860dca92",
+        "size_in_bytes": 6189
+      },
+      {
+        "_path": "Lib/_pydecimal.py",
+        "path_type": "hardlink",
+        "sha256": "4b704ec20dbcad5ae15c54146d0cf41f0bb8dfeb48f0db771f74d8c61c154f54",
+        "sha256_in_prefix": "4b704ec20dbcad5ae15c54146d0cf41f0bb8dfeb48f0db771f74d8c61c154f54",
+        "size_in_bytes": 228666
+      },
+      {
+        "_path": "Lib/_pyio.py",
+        "path_type": "hardlink",
+        "sha256": "1f64a1ad666b58126b29fe79a798240807e1e46dd3be347af5e3c4b10150a7fb",
+        "sha256_in_prefix": "1f64a1ad666b58126b29fe79a798240807e1e46dd3be347af5e3c4b10150a7fb",
+        "size_in_bytes": 93316
+      },
+      {
+        "_path": "Lib/_sitebuiltins.py",
+        "path_type": "hardlink",
+        "sha256": "e9d3761e39a049203c19f4c4cd9259f3636f10a2c0f58cea579f0400fa453294",
+        "sha256_in_prefix": "e9d3761e39a049203c19f4c4cd9259f3636f10a2c0f58cea579f0400fa453294",
+        "size_in_bytes": 3115
+      },
+      {
+        "_path": "Lib/_strptime.py",
+        "path_type": "hardlink",
+        "sha256": "065e6597af214f795d16c018fdfe60ec93ab1d2703bdb159e0576173a19a72f8",
+        "sha256_in_prefix": "065e6597af214f795d16c018fdfe60ec93ab1d2703bdb159e0576173a19a72f8",
+        "size_in_bytes": 25277
+      },
+      {
+        "_path": "Lib/_threading_local.py",
+        "path_type": "hardlink",
+        "sha256": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb",
+        "sha256_in_prefix": "e1bf3dae66d0bfa63c8bb8a1d10c611203c35c636f7f5191fd56105788ef29cb",
+        "size_in_bytes": 7220
+      },
+      {
+        "_path": "Lib/_weakrefset.py",
+        "path_type": "hardlink",
+        "sha256": "49fb432325ef836f89caa60e50b152eb6f32b700ed71fedcd4d56815723f77ba",
+        "sha256_in_prefix": "49fb432325ef836f89caa60e50b152eb6f32b700ed71fedcd4d56815723f77ba",
+        "size_in_bytes": 5923
+      },
+      {
+        "_path": "Lib/abc.py",
+        "path_type": "hardlink",
+        "sha256": "937d73a33adba6b015171e0e2670ec4ddfe155e36f9ab4bf711853d3b7df6419",
+        "sha256_in_prefix": "937d73a33adba6b015171e0e2670ec4ddfe155e36f9ab4bf711853d3b7df6419",
+        "size_in_bytes": 4920
+      },
+      {
+        "_path": "Lib/aifc.py",
+        "path_type": "hardlink",
+        "sha256": "bb1a32c21c6ce68e9858cd5ec983643afa586a4f6d613210e49ea7346ba02833",
+        "sha256_in_prefix": "bb1a32c21c6ce68e9858cd5ec983643afa586a4f6d613210e49ea7346ba02833",
+        "size_in_bytes": 32605
+      },
+      {
+        "_path": "Lib/antigravity.py",
+        "path_type": "hardlink",
+        "sha256": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967",
+        "sha256_in_prefix": "8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967",
+        "size_in_bytes": 500
+      },
+      {
+        "_path": "Lib/argparse.py",
+        "path_type": "hardlink",
+        "sha256": "1f549e2f7f896f884a9de998a05d7dadb930594262a43d59517b06ff3ee6fc51",
+        "sha256_in_prefix": "1f549e2f7f896f884a9de998a05d7dadb930594262a43d59517b06ff3ee6fc51",
+        "size_in_bytes": 98119
+      },
+      {
+        "_path": "Lib/ast.py",
+        "path_type": "hardlink",
+        "sha256": "c7a744d71f4a90405eee1520b092f7ddc671a815194393479f170cc2868ae0e6",
+        "sha256_in_prefix": "c7a744d71f4a90405eee1520b092f7ddc671a815194393479f170cc2868ae0e6",
+        "size_in_bytes": 56256
+      },
+      {
+        "_path": "Lib/asynchat.py",
+        "path_type": "hardlink",
+        "sha256": "027b3a30c97743e6b0a4f29caaad8f31803adb83bde94c2fa22d31894286b22b",
+        "sha256_in_prefix": "027b3a30c97743e6b0a4f29caaad8f31803adb83bde94c2fa22d31894286b22b",
+        "size_in_bytes": 11321
+      },
+      {
+        "_path": "Lib/asyncio/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "4048c0bb0a795d582ddc49c432fd90ade567e45b4f5291b39e6f00edff4764f2",
+        "sha256_in_prefix": "4048c0bb0a795d582ddc49c432fd90ade567e45b4f5291b39e6f00edff4764f2",
+        "size_in_bytes": 1279
+      },
+      {
+        "_path": "Lib/asyncio/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "318f003efb1ad1cc2c3107a3f0e21d6e9a32f8599b8b0ad66d80b03d9e7bcc21",
+        "sha256_in_prefix": "318f003efb1ad1cc2c3107a3f0e21d6e9a32f8599b8b0ad66d80b03d9e7bcc21",
+        "size_in_bytes": 3379
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4a450df9822cd5a22f65fcf146d9f437bd6539fcfdef33735668f4ea6dc23598",
+        "sha256_in_prefix": "4a450df9822cd5a22f65fcf146d9f437bd6539fcfdef33735668f4ea6dc23598",
+        "size_in_bytes": 764
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "501b2a4e0356f51f4ddb87539d77bebe4e793fec82ac010ea59f68d9de054245",
+        "sha256_in_prefix": "501b2a4e0356f51f4ddb87539d77bebe4e793fec82ac010ea59f68d9de054245",
+        "size_in_bytes": 3195
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/base_events.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a3f9f2d9aaf9251014133d0edd2a0be4c667d0b713d2a2cbb8fce3a279ad6f7b",
+        "sha256_in_prefix": "a3f9f2d9aaf9251014133d0edd2a0be4c667d0b713d2a2cbb8fce3a279ad6f7b",
+        "size_in_bytes": 52283
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/base_futures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "221b38785b1f40a4ced605ede50575d2d2855e63dc79e17e66ff80c830314965",
+        "sha256_in_prefix": "221b38785b1f40a4ced605ede50575d2d2855e63dc79e17e66ff80c830314965",
+        "size_in_bytes": 1893
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/base_subprocess.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "17d882e64a0c07aa9c94866c84d0e0a1380b12fd47ca6d3776e09a4000dc4c6f",
+        "sha256_in_prefix": "17d882e64a0c07aa9c94866c84d0e0a1380b12fd47ca6d3776e09a4000dc4c6f",
+        "size_in_bytes": 9395
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/base_tasks.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "68803d3b14daf9dad5517f89bfa3123eac7855f5130dcde9d8d34ebd3a6e0d68",
+        "sha256_in_prefix": "68803d3b14daf9dad5517f89bfa3123eac7855f5130dcde9d8d34ebd3a6e0d68",
+        "size_in_bytes": 1929
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/constants.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "baa41dbed6bc9b0ef92b0c402c99e7cf38507c08ca3aee3923959b55cd767692",
+        "sha256_in_prefix": "baa41dbed6bc9b0ef92b0c402c99e7cf38507c08ca3aee3923959b55cd767692",
+        "size_in_bytes": 566
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/coroutines.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "98c932a3eebbcbec4041343d0584923465b537e7a912e5e0bc3470e25cf3984e",
+        "sha256_in_prefix": "98c932a3eebbcbec4041343d0584923465b537e7a912e5e0bc3470e25cf3984e",
+        "size_in_bytes": 6622
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/events.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "751743081c65ba7e121eb5dfa9143c71af32edcf8cb8ccd00a5cf84df237e0b6",
+        "sha256_in_prefix": "751743081c65ba7e121eb5dfa9143c71af32edcf8cb8ccd00a5cf84df237e0b6",
+        "size_in_bytes": 28143
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/exceptions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "78437656f7a1f7fd225b264dd250d2fe1f5ded1390fe2fcc74781df23d9db052",
+        "sha256_in_prefix": "78437656f7a1f7fd225b264dd250d2fe1f5ded1390fe2fcc74781df23d9db052",
+        "size_in_bytes": 2538
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/format_helpers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "55f58303da34ee19cc9bf205aea5a7f2068d41e0d4dc52b3a5c0b45366ae5416",
+        "sha256_in_prefix": "55f58303da34ee19cc9bf205aea5a7f2068d41e0d4dc52b3a5c0b45366ae5416",
+        "size_in_bytes": 2309
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/futures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3861d82dfe5a58bdca2814df889f6c5b370cdf41dfd8a93edf482930dc01bf32",
+        "sha256_in_prefix": "3861d82dfe5a58bdca2814df889f6c5b370cdf41dfd8a93edf482930dc01bf32",
+        "size_in_bytes": 11761
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/locks.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f21dc2881d743f5df462b5209a8053284b3fd7b57f66f491756d5afd1d7a6029",
+        "sha256_in_prefix": "f21dc2881d743f5df462b5209a8053284b3fd7b57f66f491756d5afd1d7a6029",
+        "size_in_bytes": 14449
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/log.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ee892da9f347267300f40af3ba1ed312c1d95b43bded130fef9c925f2ffb80eb",
+        "sha256_in_prefix": "ee892da9f347267300f40af3ba1ed312c1d95b43bded130fef9c925f2ffb80eb",
+        "size_in_bytes": 211
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/proactor_events.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cb9b4bbe983c550b133e363a9889b4960645f5c0efe3c083c318f9575df37ab3",
+        "sha256_in_prefix": "cb9b4bbe983c550b133e363a9889b4960645f5c0efe3c083c318f9575df37ab3",
+        "size_in_bytes": 24399
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/protocols.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e828936c8c325a4960510a42ad574b6ebb092f583976c233874619895a974e0e",
+        "sha256_in_prefix": "e828936c8c325a4960510a42ad574b6ebb092f583976c233874619895a974e0e",
+        "size_in_bytes": 8420
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/queues.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "95817cf186ccdd12be701ad2d1e34021b5778a0b1e787920e157ca15c8592396",
+        "sha256_in_prefix": "95817cf186ccdd12be701ad2d1e34021b5778a0b1e787920e157ca15c8592396",
+        "size_in_bytes": 8449
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/runners.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "64c744cd736147989bd14a4937d325e1a5347d38c54accad7f006390a5277fdb",
+        "sha256_in_prefix": "64c744cd736147989bd14a4937d325e1a5347d38c54accad7f006390a5277fdb",
+        "size_in_bytes": 2192
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/selector_events.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e161daf392c10b8367cb3cb0b2b5fbe99b877a25abdf15520853ccb5cec93a19",
+        "sha256_in_prefix": "e161daf392c10b8367cb3cb0b2b5fbe99b877a25abdf15520853ccb5cec93a19",
+        "size_in_bytes": 29701
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/sslproto.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6346fc897c55da9db8ce7800609e10a491a9f2540f6a0017c4268dd6e7fbff53",
+        "sha256_in_prefix": "6346fc897c55da9db8ce7800609e10a491a9f2540f6a0017c4268dd6e7fbff53",
+        "size_in_bytes": 21871
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/staggered.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b9c79fd92ba88175632d9ecc7732b5bc416f860affff3865237551c406fbf558",
+        "sha256_in_prefix": "b9c79fd92ba88175632d9ecc7732b5bc416f860affff3865237551c406fbf558",
+        "size_in_bytes": 4145
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/streams.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a9763ac71d80c727c74e4806d4b1b294bac384f12a3373bc901fc267bf100f7f",
+        "sha256_in_prefix": "a9763ac71d80c727c74e4806d4b1b294bac384f12a3373bc901fc267bf100f7f",
+        "size_in_bytes": 20571
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/subprocess.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d87a99c483a6a5cd2a980ff9eb8a694a2a44d119cd10592906ea9be4f102bd93",
+        "sha256_in_prefix": "d87a99c483a6a5cd2a980ff9eb8a694a2a44d119cd10592906ea9be4f102bd93",
+        "size_in_bytes": 7320
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/tasks.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "05c37635c59e583c353de977a36ae9c569d0e16bbf37c9bfe5254fa715587bfd",
+        "sha256_in_prefix": "05c37635c59e583c353de977a36ae9c569d0e16bbf37c9bfe5254fa715587bfd",
+        "size_in_bytes": 24272
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/threads.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "82b8321825bf4c4f308e46661988af6ce4416257276589ad6522810a5d6f0189",
+        "sha256_in_prefix": "82b8321825bf4c4f308e46661988af6ce4416257276589ad6522810a5d6f0189",
+        "size_in_bytes": 963
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/transports.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "63f1e38dfb25323fd440f4b53c7904ca37655b28cc5cb7a2acb7a1c25432b17d",
+        "sha256_in_prefix": "63f1e38dfb25323fd440f4b53c7904ca37655b28cc5cb7a2acb7a1c25432b17d",
+        "size_in_bytes": 12519
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/trsock.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4d4964a52d1770272a523249669c9beef282908e20e9ab9f95d62f9e93e5c360",
+        "sha256_in_prefix": "4d4964a52d1770272a523249669c9beef282908e20e9ab9f95d62f9e93e5c360",
+        "size_in_bytes": 8554
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/unix_events.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cf1161e4e6b334747ff9227b83cf626116014835b06aec7c6a102d17cdf69691",
+        "sha256_in_prefix": "cf1161e4e6b334747ff9227b83cf626116014835b06aec7c6a102d17cdf69691",
+        "size_in_bytes": 42029
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/windows_events.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9a72a0e42e2fcf94842e539a56227e882837876605b752ec72cf3f262484ec64",
+        "sha256_in_prefix": "9a72a0e42e2fcf94842e539a56227e882837876605b752ec72cf3f262484ec64",
+        "size_in_bytes": 24716
+      },
+      {
+        "_path": "Lib/asyncio/__pycache__/windows_utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de6ea8149daec10b081fc81246c0fea413d1b5cccbdd82d14be8218366872837",
+        "sha256_in_prefix": "de6ea8149daec10b081fc81246c0fea413d1b5cccbdd82d14be8218366872837",
+        "size_in_bytes": 4488
+      },
+      {
+        "_path": "Lib/asyncio/base_events.py",
+        "path_type": "hardlink",
+        "sha256": "70e50fca7688f9304bc28ed7e9f5bcabd2a9d18108decdb02ef91b6f19ec480e",
+        "sha256_in_prefix": "70e50fca7688f9304bc28ed7e9f5bcabd2a9d18108decdb02ef91b6f19ec480e",
+        "size_in_bytes": 74192
+      },
+      {
+        "_path": "Lib/asyncio/base_futures.py",
+        "path_type": "hardlink",
+        "sha256": "6305968656c74facd06240e0a5352a8cb6db569c1c91f4908277d2723bae411d",
+        "sha256_in_prefix": "6305968656c74facd06240e0a5352a8cb6db569c1c91f4908277d2723bae411d",
+        "size_in_bytes": 2574
+      },
+      {
+        "_path": "Lib/asyncio/base_subprocess.py",
+        "path_type": "hardlink",
+        "sha256": "877cd264f49b3fbeaf0de6d7f0369e007a5e02f601d7ab72f3117a056aaa3cea",
+        "sha256_in_prefix": "877cd264f49b3fbeaf0de6d7f0369e007a5e02f601d7ab72f3117a056aaa3cea",
+        "size_in_bytes": 8843
+      },
+      {
+        "_path": "Lib/asyncio/base_tasks.py",
+        "path_type": "hardlink",
+        "sha256": "fb8c4508749d9ff286eeea60a9cc179b21480467f93d3b440ddc5caf908ec3bd",
+        "sha256_in_prefix": "fb8c4508749d9ff286eeea60a9cc179b21480467f93d3b440ddc5caf908ec3bd",
+        "size_in_bytes": 2467
+      },
+      {
+        "_path": "Lib/asyncio/constants.py",
+        "path_type": "hardlink",
+        "sha256": "e3bb7404a839c2ba512def9ef8ce206ff4ae3499eeec840c3d08d633d5e72d5d",
+        "sha256_in_prefix": "e3bb7404a839c2ba512def9ef8ce206ff4ae3499eeec840c3d08d633d5e72d5d",
+        "size_in_bytes": 888
+      },
+      {
+        "_path": "Lib/asyncio/coroutines.py",
+        "path_type": "hardlink",
+        "sha256": "55132b9bd716b607d231f97098d5c74484b4317f97877d7fcc9256ee56e0e154",
+        "sha256_in_prefix": "55132b9bd716b607d231f97098d5c74484b4317f97877d7fcc9256ee56e0e154",
+        "size_in_bytes": 8797
+      },
+      {
+        "_path": "Lib/asyncio/events.py",
+        "path_type": "hardlink",
+        "sha256": "430b961e99e225fa5386bdbea3cc40c5ecd53c86de2f3d8f42391722d7d5ff55",
+        "sha256_in_prefix": "430b961e99e225fa5386bdbea3cc40c5ecd53c86de2f3d8f42391722d7d5ff55",
+        "size_in_bytes": 26451
+      },
+      {
+        "_path": "Lib/asyncio/exceptions.py",
+        "path_type": "hardlink",
+        "sha256": "026283dbf8f6ab28f1aede20d07f13ec60653293e7da495eac2fd13aa3f6e289",
+        "sha256_in_prefix": "026283dbf8f6ab28f1aede20d07f13ec60653293e7da495eac2fd13aa3f6e289",
+        "size_in_bytes": 1633
+      },
+      {
+        "_path": "Lib/asyncio/format_helpers.py",
+        "path_type": "hardlink",
+        "sha256": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59",
+        "sha256_in_prefix": "6377b672b3f4ba8b6f0f7a5f0ea00cde24c8cddc0ca764e3329f302763477f59",
+        "size_in_bytes": 2404
+      },
+      {
+        "_path": "Lib/asyncio/futures.py",
+        "path_type": "hardlink",
+        "sha256": "c120a077d1e50ebf3e939eaac75348d595920de958a0109d9a633aad5f12acb7",
+        "sha256_in_prefix": "c120a077d1e50ebf3e939eaac75348d595920de958a0109d9a633aad5f12acb7",
+        "size_in_bytes": 14042
+      },
+      {
+        "_path": "Lib/asyncio/locks.py",
+        "path_type": "hardlink",
+        "sha256": "157b1f0dbf2aa01aa233357ed7b829abdd8a834db76f31dff1c7a6261a31d4c0",
+        "sha256_in_prefix": "157b1f0dbf2aa01aa233357ed7b829abdd8a834db76f31dff1c7a6261a31d4c0",
+        "size_in_bytes": 15181
+      },
+      {
+        "_path": "Lib/asyncio/log.py",
+        "path_type": "hardlink",
+        "sha256": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2",
+        "sha256_in_prefix": "80e4cc3ded4b138baba486519e7444801a23d6ac35f229d336a407a96af7e8d2",
+        "size_in_bytes": 124
+      },
+      {
+        "_path": "Lib/asyncio/proactor_events.py",
+        "path_type": "hardlink",
+        "sha256": "3bcbbd52869c4198a471b1e5666999ebdb1fe83107a94d21ecd59fbf04ea6944",
+        "sha256_in_prefix": "3bcbbd52869c4198a471b1e5666999ebdb1fe83107a94d21ecd59fbf04ea6944",
+        "size_in_bytes": 32146
+      },
+      {
+        "_path": "Lib/asyncio/protocols.py",
+        "path_type": "hardlink",
+        "sha256": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6",
+        "sha256_in_prefix": "1d1b49988c338b4ef06e30f9e92d9db2e00080c341f0a3f573bb8312deb8aff6",
+        "size_in_bytes": 6957
+      },
+      {
+        "_path": "Lib/asyncio/queues.py",
+        "path_type": "hardlink",
+        "sha256": "c87bb5f2b9af15eea10a8968cb9be123fb8aa61a031584a87d58d304b49be5bd",
+        "sha256_in_prefix": "c87bb5f2b9af15eea10a8968cb9be123fb8aa61a031584a87d58d304b49be5bd",
+        "size_in_bytes": 8305
+      },
+      {
+        "_path": "Lib/asyncio/runners.py",
+        "path_type": "hardlink",
+        "sha256": "8490956689c96f6ffdc25930e73d24dbb259cb104c14361f655f2dace74f9854",
+        "sha256_in_prefix": "8490956689c96f6ffdc25930e73d24dbb259cb104c14361f655f2dace74f9854",
+        "size_in_bytes": 2125
+      },
+      {
+        "_path": "Lib/asyncio/selector_events.py",
+        "path_type": "hardlink",
+        "sha256": "f7a20822200561458c4235892fb9540262ac6e9eff7d68b0cce797049f58efd1",
+        "sha256_in_prefix": "f7a20822200561458c4235892fb9540262ac6e9eff7d68b0cce797049f58efd1",
+        "size_in_bytes": 39500
+      },
+      {
+        "_path": "Lib/asyncio/sslproto.py",
+        "path_type": "hardlink",
+        "sha256": "8da7cf9187e6e99cfc4331fb273673a2a7968c4323680add7b3c3e3e669cddde",
+        "sha256_in_prefix": "8da7cf9187e6e99cfc4331fb273673a2a7968c4323680add7b3c3e3e669cddde",
+        "size_in_bytes": 27459
+      },
+      {
+        "_path": "Lib/asyncio/staggered.py",
+        "path_type": "hardlink",
+        "sha256": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9",
+        "sha256_in_prefix": "ff289bdc20a50ad9620393479d785bc653e71c2e3298f53ab27907cd136498e9",
+        "size_in_bytes": 5992
+      },
+      {
+        "_path": "Lib/asyncio/streams.py",
+        "path_type": "hardlink",
+        "sha256": "6fe5aa0c1e7a2ed8e0ef6db5cd645bb2347018a23f90b03f03dac972cc24db5d",
+        "sha256_in_prefix": "6fe5aa0c1e7a2ed8e0ef6db5cd645bb2347018a23f90b03f03dac972cc24db5d",
+        "size_in_bytes": 26656
+      },
+      {
+        "_path": "Lib/asyncio/subprocess.py",
+        "path_type": "hardlink",
+        "sha256": "876d9f9fe00bc7f8ed1afd6979e605f90f652f20576a4b39c1f060a7c3aaf82f",
+        "sha256_in_prefix": "876d9f9fe00bc7f8ed1afd6979e605f90f652f20576a4b39c1f060a7c3aaf82f",
+        "size_in_bytes": 8070
+      },
+      {
+        "_path": "Lib/asyncio/tasks.py",
+        "path_type": "hardlink",
+        "sha256": "d309f59b15566a82bb8c500e22b9e5d5fbd1cb93111e626c010a36a7593b7d24",
+        "sha256_in_prefix": "d309f59b15566a82bb8c500e22b9e5d5fbd1cb93111e626c010a36a7593b7d24",
+        "size_in_bytes": 34419
+      },
+      {
+        "_path": "Lib/asyncio/threads.py",
+        "path_type": "hardlink",
+        "sha256": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e",
+        "sha256_in_prefix": "39d37295383641565f0c08bd992e2f661dc8051eb17e890b834fce96bde0910e",
+        "size_in_bytes": 790
+      },
+      {
+        "_path": "Lib/asyncio/transports.py",
+        "path_type": "hardlink",
+        "sha256": "986703cea28769307f7cdffc58a09ef78ea292e74d3b8d4f926e4452558998ce",
+        "sha256_in_prefix": "986703cea28769307f7cdffc58a09ef78ea292e74d3b8d4f926e4452558998ce",
+        "size_in_bytes": 10724
+      },
+      {
+        "_path": "Lib/asyncio/trsock.py",
+        "path_type": "hardlink",
+        "sha256": "435acc190d018d9421baa224d25b8d893967af5c5737a1e42f1bbf614c8e2bf3",
+        "sha256_in_prefix": "435acc190d018d9421baa224d25b8d893967af5c5737a1e42f1bbf614c8e2bf3",
+        "size_in_bytes": 5876
+      },
+      {
+        "_path": "Lib/asyncio/unix_events.py",
+        "path_type": "hardlink",
+        "sha256": "df9aeef29a9f04d4ee933b05fee4bd5ad8abaa964392fc71e30be5dc7cd9b46f",
+        "sha256_in_prefix": "df9aeef29a9f04d4ee933b05fee4bd5ad8abaa964392fc71e30be5dc7cd9b46f",
+        "size_in_bytes": 51754
+      },
+      {
+        "_path": "Lib/asyncio/windows_events.py",
+        "path_type": "hardlink",
+        "sha256": "849f1ed5c211156e6d87c9d498d032aa8a209ebde4e367f25e9f38abce26a347",
+        "sha256_in_prefix": "849f1ed5c211156e6d87c9d498d032aa8a209ebde4e367f25e9f38abce26a347",
+        "size_in_bytes": 33054
+      },
+      {
+        "_path": "Lib/asyncio/windows_utils.py",
+        "path_type": "hardlink",
+        "sha256": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0",
+        "sha256_in_prefix": "e6fcffefa2521666bc2aed0f5caf8e862c1c1014ad12d2ab5fbce09c2df9c6f0",
+        "size_in_bytes": 5060
+      },
+      {
+        "_path": "Lib/asyncore.py",
+        "path_type": "hardlink",
+        "sha256": "3ae249fadbcd2b58e3af09240582136aeea53298b1dc7a6c9d610076e744b3c3",
+        "sha256_in_prefix": "3ae249fadbcd2b58e3af09240582136aeea53298b1dc7a6c9d610076e744b3c3",
+        "size_in_bytes": 20102
+      },
+      {
+        "_path": "Lib/base64.py",
+        "path_type": "hardlink",
+        "sha256": "e711173099429960173cf5efce4227fa6f6fac7a078eca7daee2fd4eae378e8c",
+        "sha256_in_prefix": "e711173099429960173cf5efce4227fa6f6fac7a078eca7daee2fd4eae378e8c",
+        "size_in_bytes": 19861
+      },
+      {
+        "_path": "Lib/bdb.py",
+        "path_type": "hardlink",
+        "sha256": "4a5a309ae67efd0a8b61cd86afc2b271f10d5930cffb9db4fe15c9391af58720",
+        "sha256_in_prefix": "4a5a309ae67efd0a8b61cd86afc2b271f10d5930cffb9db4fe15c9391af58720",
+        "size_in_bytes": 31389
+      },
+      {
+        "_path": "Lib/binhex.py",
+        "path_type": "hardlink",
+        "sha256": "347151ad93436cac32265eb255b07c75ddb89055ee8aca2c59eebff9df5d5d73",
+        "sha256_in_prefix": "347151ad93436cac32265eb255b07c75ddb89055ee8aca2c59eebff9df5d5d73",
+        "size_in_bytes": 14784
+      },
+      {
+        "_path": "Lib/bisect.py",
+        "path_type": "hardlink",
+        "sha256": "6f213241b0d2c5cb8886c5615c6cc88f3a4ff200d7345b87a8f5bfa9d468a71b",
+        "sha256_in_prefix": "6f213241b0d2c5cb8886c5615c6cc88f3a4ff200d7345b87a8f5bfa9d468a71b",
+        "size_in_bytes": 2350
+      },
+      {
+        "_path": "Lib/bz2.py",
+        "path_type": "hardlink",
+        "sha256": "76c634cd36f697149ac6a9baaf9d8f72005b701cfb90e4090c37236cc0e48264",
+        "sha256_in_prefix": "76c634cd36f697149ac6a9baaf9d8f72005b701cfb90e4090c37236cc0e48264",
+        "size_in_bytes": 12447
+      },
+      {
+        "_path": "Lib/cProfile.py",
+        "path_type": "hardlink",
+        "sha256": "60421977dca84f29b6c3be7229b39c5ec1ebbc724852b947ca779be8f84e7a4f",
+        "sha256_in_prefix": "60421977dca84f29b6c3be7229b39c5ec1ebbc724852b947ca779be8f84e7a4f",
+        "size_in_bytes": 6347
+      },
+      {
+        "_path": "Lib/calendar.py",
+        "path_type": "hardlink",
+        "sha256": "3ef1adcb836f240e3ae9d00de4466735e6e92ec74620737bb51605a123510ec8",
+        "sha256_in_prefix": "3ef1adcb836f240e3ae9d00de4466735e6e92ec74620737bb51605a123510ec8",
+        "size_in_bytes": 24832
+      },
+      {
+        "_path": "Lib/cgi.py",
+        "path_type": "hardlink",
+        "sha256": "648775e234b3aa5323233a4dbc6ab208441e9f127466c2b50b9c53b8551720b2",
+        "sha256_in_prefix": "648775e234b3aa5323233a4dbc6ab208441e9f127466c2b50b9c53b8551720b2",
+        "size_in_bytes": 33935
+      },
+      {
+        "_path": "Lib/cgitb.py",
+        "path_type": "hardlink",
+        "sha256": "bcb2647893bde25fb8702af2641a0283f5f198ab6e25c998a222a78138429f62",
+        "sha256_in_prefix": "bcb2647893bde25fb8702af2641a0283f5f198ab6e25c998a222a78138429f62",
+        "size_in_bytes": 12096
+      },
+      {
+        "_path": "Lib/chunk.py",
+        "path_type": "hardlink",
+        "sha256": "34a5d2cde2e00a03acd84768ccd352ebdc3ac008a8f41ab1caee698e4a474ca0",
+        "sha256_in_prefix": "34a5d2cde2e00a03acd84768ccd352ebdc3ac008a8f41ab1caee698e4a474ca0",
+        "size_in_bytes": 5435
+      },
+      {
+        "_path": "Lib/cmd.py",
+        "path_type": "hardlink",
+        "sha256": "1b18b978b7f2e2a587aa77f0bc7a6130718c4b680dd19cc749eb2ee7eb8b9590",
+        "sha256_in_prefix": "1b18b978b7f2e2a587aa77f0bc7a6130718c4b680dd19cc749eb2ee7eb8b9590",
+        "size_in_bytes": 14860
+      },
+      {
+        "_path": "Lib/code.py",
+        "path_type": "hardlink",
+        "sha256": "266841655656d5b2370e80addcdb959f5173142d5e3778b489e734802447c5e8",
+        "sha256_in_prefix": "266841655656d5b2370e80addcdb959f5173142d5e3778b489e734802447c5e8",
+        "size_in_bytes": 10622
+      },
+      {
+        "_path": "Lib/codecs.py",
+        "path_type": "hardlink",
+        "sha256": "8c88dc3fa4a2b85759c8c5394dce9c0a5248e99ea85fc57f42d7372da0e69256",
+        "sha256_in_prefix": "8c88dc3fa4a2b85759c8c5394dce9c0a5248e99ea85fc57f42d7372da0e69256",
+        "size_in_bytes": 36673
+      },
+      {
+        "_path": "Lib/codeop.py",
+        "path_type": "hardlink",
+        "sha256": "da65a8d00a767249759a766faad19a3b1f473bfb815433fc8d1d4cacda95b849",
+        "sha256_in_prefix": "da65a8d00a767249759a766faad19a3b1f473bfb815433fc8d1d4cacda95b849",
+        "size_in_bytes": 6326
+      },
+      {
+        "_path": "Lib/collections/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "0521f8084998b03f29317872a35531adea4708b32b0ebd4cfdf8e178a93dba76",
+        "sha256_in_prefix": "0521f8084998b03f29317872a35531adea4708b32b0ebd4cfdf8e178a93dba76",
+        "size_in_bytes": 49819
+      },
+      {
+        "_path": "Lib/collections/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e56f1e9550ba4dab97ccd11be3d1aa0a152ba3efe9c9e92c936d8a61919c0d91",
+        "sha256_in_prefix": "e56f1e9550ba4dab97ccd11be3d1aa0a152ba3efe9c9e92c936d8a61919c0d91",
+        "size_in_bytes": 48084
+      },
+      {
+        "_path": "Lib/collections/__pycache__/abc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "03df7fafaf80d56dac8d767ed0a643e7b6d44b84e2a3d4efa9316b8e09b6df23",
+        "sha256_in_prefix": "03df7fafaf80d56dac8d767ed0a643e7b6d44b84e2a3d4efa9316b8e09b6df23",
+        "size_in_bytes": 220
+      },
+      {
+        "_path": "Lib/collections/abc.py",
+        "path_type": "hardlink",
+        "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10",
+        "sha256_in_prefix": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10",
+        "size_in_bytes": 119
+      },
+      {
+        "_path": "Lib/colorsys.py",
+        "path_type": "hardlink",
+        "sha256": "134f6ffca766df778fc0aa49ada506fc1b351911da50fd83191dde19d80ea9a1",
+        "sha256_in_prefix": "134f6ffca766df778fc0aa49ada506fc1b351911da50fd83191dde19d80ea9a1",
+        "size_in_bytes": 4064
+      },
+      {
+        "_path": "Lib/compileall.py",
+        "path_type": "hardlink",
+        "sha256": "5d026b44d20d1f9753fb081eb572e5da748f12cab9b3933a750cdbd435c1df9b",
+        "sha256_in_prefix": "5d026b44d20d1f9753fb081eb572e5da748f12cab9b3933a750cdbd435c1df9b",
+        "size_in_bytes": 20105
+      },
+      {
+        "_path": "Lib/concurrent/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8",
+        "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8",
+        "size_in_bytes": 38
+      },
+      {
+        "_path": "Lib/concurrent/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0d9ba2452ea8e41b07b87b01233f6b38611950dc79c429b1f1445117facd1abb",
+        "sha256_in_prefix": "0d9ba2452ea8e41b07b87b01233f6b38611950dc79c429b1f1445117facd1abb",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "Lib/concurrent/futures/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "ff1f05fa12bc54681fa90da6197d7b2aaa09545e92b2a407769412b99b8966f9",
+        "sha256_in_prefix": "ff1f05fa12bc54681fa90da6197d7b2aaa09545e92b2a407769412b99b8966f9",
+        "size_in_bytes": 1554
+      },
+      {
+        "_path": "Lib/concurrent/futures/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fba6cc9482c83ac7313aedbe5162207eab70256b1d5bb1ecabcac142bb09f4ae",
+        "sha256_in_prefix": "fba6cc9482c83ac7313aedbe5162207eab70256b1d5bb1ecabcac142bb09f4ae",
+        "size_in_bytes": 1093
+      },
+      {
+        "_path": "Lib/concurrent/futures/__pycache__/_base.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b82b8a782cc862345181142216341b20ca1404945f4a4a4245a1e66dfe672ae1",
+        "sha256_in_prefix": "b82b8a782cc862345181142216341b20ca1404945f4a4a4245a1e66dfe672ae1",
+        "size_in_bytes": 22419
+      },
+      {
+        "_path": "Lib/concurrent/futures/__pycache__/process.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d5b1f567f1f1bbcef4543713cb7d5170b04e53adb310506cf91188ad4933a21c",
+        "sha256_in_prefix": "d5b1f567f1f1bbcef4543713cb7d5170b04e53adb310506cf91188ad4933a21c",
+        "size_in_bytes": 21379
+      },
+      {
+        "_path": "Lib/concurrent/futures/__pycache__/thread.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "93480d9bf9705ca2246a59c21dfa0974f56b592006827d42761dc1f124cc2c6f",
+        "sha256_in_prefix": "93480d9bf9705ca2246a59c21dfa0974f56b592006827d42761dc1f124cc2c6f",
+        "size_in_bytes": 5889
+      },
+      {
+        "_path": "Lib/concurrent/futures/_base.py",
+        "path_type": "hardlink",
+        "sha256": "07d83e2a0bbc47ded2a342aac9d938462919d712a12e100bba8cfde12868bc57",
+        "sha256_in_prefix": "07d83e2a0bbc47ded2a342aac9d938462919d712a12e100bba8cfde12868bc57",
+        "size_in_bytes": 22577
+      },
+      {
+        "_path": "Lib/concurrent/futures/process.py",
+        "path_type": "hardlink",
+        "sha256": "4afad77c58e7d484f78830c821a6581acb685955888f57d773a230252f728722",
+        "sha256_in_prefix": "4afad77c58e7d484f78830c821a6581acb685955888f57d773a230252f728722",
+        "size_in_bytes": 31395
+      },
+      {
+        "_path": "Lib/concurrent/futures/thread.py",
+        "path_type": "hardlink",
+        "sha256": "b06f8899881193efc72cfc3ebf2836dce4e668b3856ad35f4016616d643a519e",
+        "sha256_in_prefix": "b06f8899881193efc72cfc3ebf2836dce4e668b3856ad35f4016616d643a519e",
+        "size_in_bytes": 8771
+      },
+      {
+        "_path": "Lib/configparser.py",
+        "path_type": "hardlink",
+        "sha256": "fb62822bc88a645d02f99af84a83d014045d3a1358ed5eab620566bc5773ffc5",
+        "sha256_in_prefix": "fb62822bc88a645d02f99af84a83d014045d3a1358ed5eab620566bc5773ffc5",
+        "size_in_bytes": 54584
+      },
+      {
+        "_path": "Lib/contextlib.py",
+        "path_type": "hardlink",
+        "sha256": "5855960050debd99cc1df152131b9535379d2101eecbca5d0735ad7e8c9a685d",
+        "sha256_in_prefix": "5855960050debd99cc1df152131b9535379d2101eecbca5d0735ad7e8c9a685d",
+        "size_in_bytes": 24624
+      },
+      {
+        "_path": "Lib/contextvars.py",
+        "path_type": "hardlink",
+        "sha256": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a",
+        "sha256_in_prefix": "5ed260be8d1f4fe92261b7810b4bb1e8539c42093d7493f677d076e1a87f459a",
+        "size_in_bytes": 129
+      },
+      {
+        "_path": "Lib/copy.py",
+        "path_type": "hardlink",
+        "sha256": "ecc9ca905b83b9550f478781c1999c928e229aed4bdc4bc41bfe15deac886a65",
+        "sha256_in_prefix": "ecc9ca905b83b9550f478781c1999c928e229aed4bdc4bc41bfe15deac886a65",
+        "size_in_bytes": 8650
+      },
+      {
+        "_path": "Lib/copyreg.py",
+        "path_type": "hardlink",
+        "sha256": "55c1fa8ee6e89eb8645441d5fc1e215c5ec95d8fce218107d3f9d9e25ca31a2d",
+        "sha256_in_prefix": "55c1fa8ee6e89eb8645441d5fc1e215c5ec95d8fce218107d3f9d9e25ca31a2d",
+        "size_in_bytes": 7274
+      },
+      {
+        "_path": "Lib/crypt.py",
+        "path_type": "hardlink",
+        "sha256": "9fbeaf016c5e0b4cc0285110f99e06bc8056b76351dd99459ef827a23f74f781",
+        "sha256_in_prefix": "9fbeaf016c5e0b4cc0285110f99e06bc8056b76351dd99459ef827a23f74f781",
+        "size_in_bytes": 3819
+      },
+      {
+        "_path": "Lib/csv.py",
+        "path_type": "hardlink",
+        "sha256": "7227f2d4774fb884d56bcc11b7de53668ef8640ef9c51edacebca8cd35d7a1f7",
+        "sha256_in_prefix": "7227f2d4774fb884d56bcc11b7de53668ef8640ef9c51edacebca8cd35d7a1f7",
+        "size_in_bytes": 16144
+      },
+      {
+        "_path": "Lib/ctypes/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "9b99fa34cb2c454490337a62a9d91f5828c1a4f1ac22d94d94fffea34a2d612e",
+        "sha256_in_prefix": "9b99fa34cb2c454490337a62a9d91f5828c1a4f1ac22d94d94fffea34a2d612e",
+        "size_in_bytes": 17988
+      },
+      {
+        "_path": "Lib/ctypes/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "051f44dc432f2ed107cf907c3e848af55c2ef7ebfc47dcaa11eb535ad547469e",
+        "sha256_in_prefix": "051f44dc432f2ed107cf907c3e848af55c2ef7ebfc47dcaa11eb535ad547469e",
+        "size_in_bytes": 16417
+      },
+      {
+        "_path": "Lib/ctypes/__pycache__/_aix.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3c967299110178faa263c592f78dd8e23c275755784c9fd056be08529a272cf6",
+        "sha256_in_prefix": "3c967299110178faa263c592f78dd8e23c275755784c9fd056be08529a272cf6",
+        "size_in_bytes": 9819
+      },
+      {
+        "_path": "Lib/ctypes/__pycache__/_endian.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "228fb390f246c344a2766dcdf1e754865f76517ff5c02af9b4593474c7f3995f",
+        "sha256_in_prefix": "228fb390f246c344a2766dcdf1e754865f76517ff5c02af9b4593474c7f3995f",
+        "size_in_bytes": 1914
+      },
+      {
+        "_path": "Lib/ctypes/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3885db7f32c31570c6008f28d1dd29341730325e65ecc69e7c87437d07d77804",
+        "sha256_in_prefix": "3885db7f32c31570c6008f28d1dd29341730325e65ecc69e7c87437d07d77804",
+        "size_in_bytes": 8655
+      },
+      {
+        "_path": "Lib/ctypes/__pycache__/wintypes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9d6e7ff5050534b575a36e524189b70073cd207274fd003805559472091fa77f",
+        "sha256_in_prefix": "9d6e7ff5050534b575a36e524189b70073cd207274fd003805559472091fa77f",
+        "size_in_bytes": 5088
+      },
+      {
+        "_path": "Lib/ctypes/_aix.py",
+        "path_type": "hardlink",
+        "sha256": "3aaaa326d9c45e115d87e9e52874b1acd766cb4c578cecad667177d50849034c",
+        "sha256_in_prefix": "3aaaa326d9c45e115d87e9e52874b1acd766cb4c578cecad667177d50849034c",
+        "size_in_bytes": 12575
+      },
+      {
+        "_path": "Lib/ctypes/_endian.py",
+        "path_type": "hardlink",
+        "sha256": "4c9944875236d4227e8fd80ca0439417870ef387a532403393da91bf7ff67e16",
+        "sha256_in_prefix": "4c9944875236d4227e8fd80ca0439417870ef387a532403393da91bf7ff67e16",
+        "size_in_bytes": 2000
+      },
+      {
+        "_path": "Lib/ctypes/macholib/README.ctypes",
+        "path_type": "hardlink",
+        "sha256": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2",
+        "sha256_in_prefix": "dc29d1da83b6a0a09a41647e4111eee878ed079c2d6b54a98fd6d8b88dd581f2",
+        "size_in_bytes": 296
+      },
+      {
+        "_path": "Lib/ctypes/macholib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd",
+        "sha256_in_prefix": "1e77c01eec8f167ed10b754f153c0c743c8e5196ae9c81dffc08f129ab56dbfd",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "Lib/ctypes/macholib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e2ffd6a82ad6ceec1511c3b9d1b5ef320a931250ee90d89d157d21c1c4720d3e",
+        "sha256_in_prefix": "e2ffd6a82ad6ceec1511c3b9d1b5ef320a931250ee90d89d157d21c1c4720d3e",
+        "size_in_bytes": 284
+      },
+      {
+        "_path": "Lib/ctypes/macholib/__pycache__/dyld.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b7e2d9109a08eac7f18f8a50aa77c20230ec65e2b08119f59befa28f01e86378",
+        "sha256_in_prefix": "b7e2d9109a08eac7f18f8a50aa77c20230ec65e2b08119f59befa28f01e86378",
+        "size_in_bytes": 4711
+      },
+      {
+        "_path": "Lib/ctypes/macholib/__pycache__/dylib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "14e98e6c5f32fe660d664247909bda822ecf95caddae50f4ab4350cd3de705a5",
+        "sha256_in_prefix": "14e98e6c5f32fe660d664247909bda822ecf95caddae50f4ab4350cd3de705a5",
+        "size_in_bytes": 1885
+      },
+      {
+        "_path": "Lib/ctypes/macholib/__pycache__/framework.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a231d4ea07aa1d3774d2765451401a26c9bd6c0c44aa6dbe8ccaaa45e7a39798",
+        "sha256_in_prefix": "a231d4ea07aa1d3774d2765451401a26c9bd6c0c44aa6dbe8ccaaa45e7a39798",
+        "size_in_bytes": 2165
+      },
+      {
+        "_path": "Lib/ctypes/macholib/dyld.py",
+        "path_type": "hardlink",
+        "sha256": "d0c8d4fd2b41360c513f49aa0bbfe2dfb79b7543bb78534aeeea9abfd18c57b7",
+        "sha256_in_prefix": "d0c8d4fd2b41360c513f49aa0bbfe2dfb79b7543bb78534aeeea9abfd18c57b7",
+        "size_in_bytes": 5415
+      },
+      {
+        "_path": "Lib/ctypes/macholib/dylib.py",
+        "path_type": "hardlink",
+        "sha256": "17de9f3d36c6ccbd97ed4ca15a908ad06663a84aa5d485714b202db7fe8e171a",
+        "sha256_in_prefix": "17de9f3d36c6ccbd97ed4ca15a908ad06663a84aa5d485714b202db7fe8e171a",
+        "size_in_bytes": 1828
+      },
+      {
+        "_path": "Lib/ctypes/macholib/fetch_macholib",
+        "path_type": "hardlink",
+        "sha256": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23",
+        "sha256_in_prefix": "a9f6faacdb1aa00ac2f68043cd445171de9639a732b861bd5e64090a2865ab23",
+        "size_in_bytes": 84
+      },
+      {
+        "_path": "Lib/ctypes/macholib/fetch_macholib.bat",
+        "path_type": "hardlink",
+        "sha256": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5",
+        "sha256_in_prefix": "7497fbdbb98afca4ac455e3a057c59bcdebaf1280e25c94741dc301f05cb53e5",
+        "size_in_bytes": 75
+      },
+      {
+        "_path": "Lib/ctypes/macholib/framework.py",
+        "path_type": "hardlink",
+        "sha256": "bf15187b7ea40c0255f14095e1091c13953c2efd98d96b409debc67669defc56",
+        "sha256_in_prefix": "bf15187b7ea40c0255f14095e1091c13953c2efd98d96b409debc67669defc56",
+        "size_in_bytes": 2201
+      },
+      {
+        "_path": "Lib/ctypes/test/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "3accba30c675661a48646b9c896fce789af85f8ed11af715ebf3720e5d9aa3c3",
+        "sha256_in_prefix": "3accba30c675661a48646b9c896fce789af85f8ed11af715ebf3720e5d9aa3c3",
+        "size_in_bytes": 399
+      },
+      {
+        "_path": "Lib/ctypes/test/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "3585b4340e0d39d24b3b462a52f70df216ed6a0838334e5108843ce6900210e6",
+        "sha256_in_prefix": "3585b4340e0d39d24b3b462a52f70df216ed6a0838334e5108843ce6900210e6",
+        "size_in_bytes": 68
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cf3a9f2662e50220b9366517d60a99d277984b06212488c041dfea7698ce58c4",
+        "sha256_in_prefix": "cf3a9f2662e50220b9366517d60a99d277984b06212488c041dfea7698ce58c4",
+        "size_in_bytes": 617
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7b94a4c4140314c842f1c73b27e7001905d606badb8eaf037d7518f288ea8e01",
+        "sha256_in_prefix": "7b94a4c4140314c842f1c73b27e7001905d606badb8eaf037d7518f288ea8e01",
+        "size_in_bytes": 200
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_anon.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "95c4cdfe96903e04702a3c67d2fd2546a36b0fdc2d419cbb40f98feea24b2875",
+        "sha256_in_prefix": "95c4cdfe96903e04702a3c67d2fd2546a36b0fdc2d419cbb40f98feea24b2875",
+        "size_in_bytes": 3092
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_array_in_pointer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1e2d545993ffa506e19d0c3a896074897579a680baa090f084939c7e77cebba2",
+        "sha256_in_prefix": "1e2d545993ffa506e19d0c3a896074897579a680baa090f084939c7e77cebba2",
+        "size_in_bytes": 1929
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_arrays.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1677986a0913a7f62c1e2e14dac3cf6867c2293de69764fc0f65078322f7a636",
+        "sha256_in_prefix": "1677986a0913a7f62c1e2e14dac3cf6867c2293de69764fc0f65078322f7a636",
+        "size_in_bytes": 9586
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_as_parameter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e428b23aa737a0ea6b4f9e8fc0c09b5501de45001907a83024026007883fa75d",
+        "sha256_in_prefix": "e428b23aa737a0ea6b4f9e8fc0c09b5501de45001907a83024026007883fa75d",
+        "size_in_bytes": 7368
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_bitfields.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eeda33df6b9fa8fa4c92f187e88e33997283c12960e9635f7c32e24ce436e63a",
+        "sha256_in_prefix": "eeda33df6b9fa8fa4c92f187e88e33997283c12960e9635f7c32e24ce436e63a",
+        "size_in_bytes": 11761
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_buffers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "784183ffbeabeea76751c8e963f5e130eefaf9cf192fdc3683dd338221891267",
+        "sha256_in_prefix": "784183ffbeabeea76751c8e963f5e130eefaf9cf192fdc3683dd338221891267",
+        "size_in_bytes": 2713
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_bytes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "59d150b9ce850da4c72fc8c4aacabfa6e44526985ce86cc066010f76127114f2",
+        "sha256_in_prefix": "59d150b9ce850da4c72fc8c4aacabfa6e44526985ce86cc066010f76127114f2",
+        "size_in_bytes": 2933
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_byteswap.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4e3efc3ee5db7eb4763b322993e11967a8a0e3dab13be1400b0fecd0f5dedc95",
+        "sha256_in_prefix": "4e3efc3ee5db7eb4763b322993e11967a8a0e3dab13be1400b0fecd0f5dedc95",
+        "size_in_bytes": 8606
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_callbacks.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9461cc42154bc35ea797924453f9e5a75677958dabf77e420f2f84d5d267f605",
+        "sha256_in_prefix": "9461cc42154bc35ea797924453f9e5a75677958dabf77e420f2f84d5d267f605",
+        "size_in_bytes": 12219
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_cast.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5c94a89f5b03eb8f9302d89d113aa026d2b941780e94ed355fe8eae04a396578",
+        "sha256_in_prefix": "5c94a89f5b03eb8f9302d89d113aa026d2b941780e94ed355fe8eae04a396578",
+        "size_in_bytes": 4186
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_cfuncs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "24792e978c46a6e49a64b2f908fee9dcb30530d47295f519f4352cfb2321f4ee",
+        "sha256_in_prefix": "24792e978c46a6e49a64b2f908fee9dcb30530d47295f519f4352cfb2321f4ee",
+        "size_in_bytes": 8717
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_checkretval.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6147a2e0919f8528c60a408a51ba6f1e751f7033f50d589fde67009a8941bb3b",
+        "sha256_in_prefix": "6147a2e0919f8528c60a408a51ba6f1e751f7033f50d589fde67009a8941bb3b",
+        "size_in_bytes": 1310
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_delattr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0be9cde8ab4d2fbb06fa74c89d46ccae2c347cb920fbce320a45d02f7ee0a3fc",
+        "sha256_in_prefix": "0be9cde8ab4d2fbb06fa74c89d46ccae2c347cb920fbce320a45d02f7ee0a3fc",
+        "size_in_bytes": 1085
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_errno.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "82d4db832381655704809ddbafce8d76fdf4634dea9bf548d9032aacfc980ea1",
+        "sha256_in_prefix": "82d4db832381655704809ddbafce8d76fdf4634dea9bf548d9032aacfc980ea1",
+        "size_in_bytes": 2205
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_find.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0725eb20139a620d788cb9fc32cbeb7a3caddd6f89cb57d4d0187d7bc043461a",
+        "sha256_in_prefix": "0725eb20139a620d788cb9fc32cbeb7a3caddd6f89cb57d4d0187d7bc043461a",
+        "size_in_bytes": 4593
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_frombuffer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7fcba49bed535cc011bd8d7bf14a1f5bcbc98e0cb11a7449eb8afe86d65b31f4",
+        "sha256_in_prefix": "7fcba49bed535cc011bd8d7bf14a1f5bcbc98e0cb11a7449eb8afe86d65b31f4",
+        "size_in_bytes": 5088
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_funcptr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3c89b5e4339352e756a2fea171d245a967a1a15f20d4aa49c9c7e08b8642f9ef",
+        "sha256_in_prefix": "3c89b5e4339352e756a2fea171d245a967a1a15f20d4aa49c9c7e08b8642f9ef",
+        "size_in_bytes": 3611
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_functions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "751669491dc410134e558af3d8596b454fa4c485187c66d07438756289950374",
+        "sha256_in_prefix": "751669491dc410134e558af3d8596b454fa4c485187c66d07438756289950374",
+        "size_in_bytes": 12251
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_incomplete.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "559ff0a85a30c3477f06006e70b91553930f4b34f6acd7f9c434c95b5e7bee1a",
+        "sha256_in_prefix": "559ff0a85a30c3477f06006e70b91553930f4b34f6acd7f9c434c95b5e7bee1a",
+        "size_in_bytes": 1113
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_init.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b2e07ea5f324af22da71a4e210c036928e9e7c16b393e011e3c57b0b33be9f88",
+        "sha256_in_prefix": "b2e07ea5f324af22da71a4e210c036928e9e7c16b393e011e3c57b0b33be9f88",
+        "size_in_bytes": 1398
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_internals.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e0217039ba58248c04da2d25228091cf9e6e27fa47f7abb3860cfceed0d0e523",
+        "sha256_in_prefix": "e0217039ba58248c04da2d25228091cf9e6e27fa47f7abb3860cfceed0d0e523",
+        "size_in_bytes": 3424
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_keeprefs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de736fd0b6c2b0efdcfb97b897bd137207896af1a207bf709598dc7a0279f6b7",
+        "sha256_in_prefix": "de736fd0b6c2b0efdcfb97b897bd137207896af1a207bf709598dc7a0279f6b7",
+        "size_in_bytes": 5591
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_libc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6be52cf60890b3065e78c726f7843a1793afe7f76b1777a4612d633aa891bf2d",
+        "sha256_in_prefix": "6be52cf60890b3065e78c726f7843a1793afe7f76b1777a4612d633aa891bf2d",
+        "size_in_bytes": 1466
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_loading.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "403d33f93dc7cb938a0aa9e82b4dd8547cceacfefe692c5352267891976c1c32",
+        "sha256_in_prefix": "403d33f93dc7cb938a0aa9e82b4dd8547cceacfefe692c5352267891976c1c32",
+        "size_in_bytes": 5129
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_macholib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c6a57ac36d7e859634ddc3802a5aef57eaa7e275cf59ca41875e49f527be881d",
+        "sha256_in_prefix": "c6a57ac36d7e859634ddc3802a5aef57eaa7e275cf59ca41875e49f527be881d",
+        "size_in_bytes": 1253
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_memfunctions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "720c8c04d4f6cbe6718200d8c352e2779094cb0b753fbfdcd07776bfe80909af",
+        "sha256_in_prefix": "720c8c04d4f6cbe6718200d8c352e2779094cb0b753fbfdcd07776bfe80909af",
+        "size_in_bytes": 3142
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_numbers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dffa9d149696cdcb431e6e8f58a526a3f1405ce343aaf8376022e2f34022f428",
+        "sha256_in_prefix": "dffa9d149696cdcb431e6e8f58a526a3f1405ce343aaf8376022e2f34022f428",
+        "size_in_bytes": 9218
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_objects.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2f051524b53275400cdacc2a06ae63935a60449effea62b90e9cd8bcbc99ffa3",
+        "sha256_in_prefix": "2f051524b53275400cdacc2a06ae63935a60449effea62b90e9cd8bcbc99ffa3",
+        "size_in_bytes": 2020
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_parameters.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "425f9053be250cc379df857b8af31cf406fcdb3fc5a8ee5c89b24d562693ef89",
+        "sha256_in_prefix": "425f9053be250cc379df857b8af31cf406fcdb3fc5a8ee5c89b24d562693ef89",
+        "size_in_bytes": 9928
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_pep3118.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a5ba9b0f8d7b58226f412ebaef330e20aa882d86677e621616af236e279f3c8f",
+        "sha256_in_prefix": "a5ba9b0f8d7b58226f412ebaef330e20aa882d86677e621616af236e279f3c8f",
+        "size_in_bytes": 5023
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_pickling.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fe18360b83ce59c77df03bc9a5bcf24ab77c98132f8ebf3080c08da12cf58ff3",
+        "sha256_in_prefix": "fe18360b83ce59c77df03bc9a5bcf24ab77c98132f8ebf3080c08da12cf58ff3",
+        "size_in_bytes": 2887
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_pointers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a6c28627b8ba3d42fe507a9ef4ede96ca2c75969e96cb16417b79a549852165f",
+        "sha256_in_prefix": "a6c28627b8ba3d42fe507a9ef4ede96ca2c75969e96cb16417b79a549852165f",
+        "size_in_bytes": 6364
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_prototypes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "643573fd957de8fbe7f66f2dc3cd7b472d252aad16d655a579ba5af199c1263c",
+        "sha256_in_prefix": "643573fd957de8fbe7f66f2dc3cd7b472d252aad16d655a579ba5af199c1263c",
+        "size_in_bytes": 5839
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_python_api.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "97d185714b3853bf19bef89cac46e947273253a9197111aa02bc5cb686889a2f",
+        "sha256_in_prefix": "97d185714b3853bf19bef89cac46e947273253a9197111aa02bc5cb686889a2f",
+        "size_in_bytes": 2718
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_random_things.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7e2fe4686ace1465fc528d2e60c55423d0770ad554f0562e3133b978522e75a6",
+        "sha256_in_prefix": "7e2fe4686ace1465fc528d2e60c55423d0770ad554f0562e3133b978522e75a6",
+        "size_in_bytes": 2961
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_refcounts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a47ff0215195ab140642e4edc84e38423ef09d69b9f563f44df48da92a94e18c",
+        "sha256_in_prefix": "a47ff0215195ab140642e4edc84e38423ef09d69b9f563f44df48da92a94e18c",
+        "size_in_bytes": 2634
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_repr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "64f11dcce5f68aedee61b3e671c3354b3f6680a30b65d6c5a129f98d57d47d6a",
+        "sha256_in_prefix": "64f11dcce5f68aedee61b3e671c3354b3f6680a30b65d6c5a129f98d57d47d6a",
+        "size_in_bytes": 1363
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_returnfuncptrs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bd65a9786895368912b792f3716d2bcfeb190e28fc484bf734b9542eb22887a2",
+        "sha256_in_prefix": "bd65a9786895368912b792f3716d2bcfeb190e28fc484bf734b9542eb22887a2",
+        "size_in_bytes": 2507
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_simplesubclasses.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "32f4b8c6b3e1170d93165a8843cb6cad52f141c3977f071117ed132808521066",
+        "sha256_in_prefix": "32f4b8c6b3e1170d93165a8843cb6cad52f141c3977f071117ed132808521066",
+        "size_in_bytes": 2103
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_sizes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d83e33eb3e12e9ec397626e1be459695d5ce05c0a681e4541eb05a027bd66fba",
+        "sha256_in_prefix": "d83e33eb3e12e9ec397626e1be459695d5ce05c0a681e4541eb05a027bd66fba",
+        "size_in_bytes": 1476
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_slicing.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "64cb90ec6bbe8e3b64eef23d8a1eb6fe1d840e26cd33868242a36a8caf609349",
+        "sha256_in_prefix": "64cb90ec6bbe8e3b64eef23d8a1eb6fe1d840e26cd33868242a36a8caf609349",
+        "size_in_bytes": 5245
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_stringptr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "977f3ecf0d0f26faee046424381fb283f097e49fa1a213a81dc24d94f4477eda",
+        "sha256_in_prefix": "977f3ecf0d0f26faee046424381fb283f097e49fa1a213a81dc24d94f4477eda",
+        "size_in_bytes": 2236
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_strings.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6a97c9dab4ff5f668cde829c4a9c7f1e8f8aaa35a01b6a44d6fa3b9f0571e165",
+        "sha256_in_prefix": "6a97c9dab4ff5f668cde829c4a9c7f1e8f8aaa35a01b6a44d6fa3b9f0571e165",
+        "size_in_bytes": 6295
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_struct_fields.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "edc0b3b8d414a66c109c2a0993de3abaef18930150f846e0896fa6b747ee1809",
+        "sha256_in_prefix": "edc0b3b8d414a66c109c2a0993de3abaef18930150f846e0896fa6b747ee1809",
+        "size_in_bytes": 3680
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_structures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "656c06a1af063765f60f068cc9da4c63f91579ad13494f8307e01dd5a39aa090",
+        "sha256_in_prefix": "656c06a1af063765f60f068cc9da4c63f91579ad13494f8307e01dd5a39aa090",
+        "size_in_bytes": 29268
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_unaligned_structures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de747caaf5fc55d92c87f73611a51964bb81476c472ecc790962e0f76e1f668e",
+        "sha256_in_prefix": "de747caaf5fc55d92c87f73611a51964bb81476c472ecc790962e0f76e1f668e",
+        "size_in_bytes": 1549
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_unicode.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3ab405a1c6afa9462341f38f191d23575177d263a19e0ed89779ebc3cf8bee7b",
+        "sha256_in_prefix": "3ab405a1c6afa9462341f38f191d23575177d263a19e0ed89779ebc3cf8bee7b",
+        "size_in_bytes": 2728
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_values.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "55108ed7699d8529cb8673b8a0484e325ad8ab98ccd33949aad203c2346b0d6e",
+        "sha256_in_prefix": "55108ed7699d8529cb8673b8a0484e325ad8ab98ccd33949aad203c2346b0d6e",
+        "size_in_bytes": 2938
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_varsize_struct.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3081fbdb2f52ac0fa73715628ccb72d4e36a1ea2db3856cc5c574817a69b57ba",
+        "sha256_in_prefix": "3081fbdb2f52ac0fa73715628ccb72d4e36a1ea2db3856cc5c574817a69b57ba",
+        "size_in_bytes": 1932
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_win32.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0140b5fd896babf7d9743100eb42b7d3c7741b1c6aa2e17314e2935496f4707d",
+        "sha256_in_prefix": "0140b5fd896babf7d9743100eb42b7d3c7741b1c6aa2e17314e2935496f4707d",
+        "size_in_bytes": 5169
+      },
+      {
+        "_path": "Lib/ctypes/test/__pycache__/test_wintypes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0cde245f76db02885a9a8fa404905bfbf67efb093f8b98749c3b6f8e0b4f0fe3",
+        "sha256_in_prefix": "0cde245f76db02885a9a8fa404905bfbf67efb093f8b98749c3b6f8e0b4f0fe3",
+        "size_in_bytes": 1136
+      },
+      {
+        "_path": "Lib/ctypes/test/test_anon.py",
+        "path_type": "hardlink",
+        "sha256": "a3433340dc3c9e058b312e079007e9475c72d4bf3e6fc1a2c1b058db8f289b51",
+        "sha256_in_prefix": "a3433340dc3c9e058b312e079007e9475c72d4bf3e6fc1a2c1b058db8f289b51",
+        "size_in_bytes": 2540
+      },
+      {
+        "_path": "Lib/ctypes/test/test_array_in_pointer.py",
+        "path_type": "hardlink",
+        "sha256": "d8ac27a86f8a8f64d1b152635e6ecd0469ddbf5dadd29870a0f969538ec5cbbc",
+        "sha256_in_prefix": "d8ac27a86f8a8f64d1b152635e6ecd0469ddbf5dadd29870a0f969538ec5cbbc",
+        "size_in_bytes": 1738
+      },
+      {
+        "_path": "Lib/ctypes/test/test_arrays.py",
+        "path_type": "hardlink",
+        "sha256": "bbcbb17674ce3fcb60d1edb8127572c8cc5f2e3022a4beb60f75a8f93869bca3",
+        "sha256_in_prefix": "bbcbb17674ce3fcb60d1edb8127572c8cc5f2e3022a4beb60f75a8f93869bca3",
+        "size_in_bytes": 7505
+      },
+      {
+        "_path": "Lib/ctypes/test/test_as_parameter.py",
+        "path_type": "hardlink",
+        "sha256": "9715608adfd9443d46131b203d3ea2e60e70efb2539f22eeed3d9c65a3ecf368",
+        "sha256_in_prefix": "9715608adfd9443d46131b203d3ea2e60e70efb2539f22eeed3d9c65a3ecf368",
+        "size_in_bytes": 6919
+      },
+      {
+        "_path": "Lib/ctypes/test/test_bitfields.py",
+        "path_type": "hardlink",
+        "sha256": "429bf3b0147217cfbb38bf2a3af976dc3ca4d098f035b2ecb392875debe9d3f7",
+        "sha256_in_prefix": "429bf3b0147217cfbb38bf2a3af976dc3ca4d098f035b2ecb392875debe9d3f7",
+        "size_in_bytes": 10355
+      },
+      {
+        "_path": "Lib/ctypes/test/test_buffers.py",
+        "path_type": "hardlink",
+        "sha256": "2822ad12a0057d5dbdd40981f066beae03c1ac0c6f5ab62daac73d53e438218c",
+        "sha256_in_prefix": "2822ad12a0057d5dbdd40981f066beae03c1ac0c6f5ab62daac73d53e438218c",
+        "size_in_bytes": 2611
+      },
+      {
+        "_path": "Lib/ctypes/test/test_bytes.py",
+        "path_type": "hardlink",
+        "sha256": "09236782d5a0add20328f237ec3c077100029d197aebd224fe4f740c5a8ca6c2",
+        "sha256_in_prefix": "09236782d5a0add20328f237ec3c077100029d197aebd224fe4f740c5a8ca6c2",
+        "size_in_bytes": 1987
+      },
+      {
+        "_path": "Lib/ctypes/test/test_byteswap.py",
+        "path_type": "hardlink",
+        "sha256": "f42798e065d95a4847a2543f79daecebdcce6e2d80e17480db20e8283c5234c7",
+        "sha256_in_prefix": "f42798e065d95a4847a2543f79daecebdcce6e2d80e17480db20e8283c5234c7",
+        "size_in_bytes": 11411
+      },
+      {
+        "_path": "Lib/ctypes/test/test_callbacks.py",
+        "path_type": "hardlink",
+        "sha256": "2de48a8909312a69fc104c340808bc13fd797cb43c91712c941affc4cb13d7b8",
+        "sha256_in_prefix": "2de48a8909312a69fc104c340808bc13fd797cb43c91712c941affc4cb13d7b8",
+        "size_in_bytes": 10574
+      },
+      {
+        "_path": "Lib/ctypes/test/test_cast.py",
+        "path_type": "hardlink",
+        "sha256": "e274510261c11e92a65d216fe64a3dffc189e0160a61fb01832d919d24c67636",
+        "sha256_in_prefix": "e274510261c11e92a65d216fe64a3dffc189e0160a61fb01832d919d24c67636",
+        "size_in_bytes": 3728
+      },
+      {
+        "_path": "Lib/ctypes/test/test_cfuncs.py",
+        "path_type": "hardlink",
+        "sha256": "527c2bd0b524240d2b31430195a6e9cc23dbaa1a7b1f269c0f2774b6dcd54bfb",
+        "sha256_in_prefix": "527c2bd0b524240d2b31430195a6e9cc23dbaa1a7b1f269c0f2774b6dcd54bfb",
+        "size_in_bytes": 7680
+      },
+      {
+        "_path": "Lib/ctypes/test/test_checkretval.py",
+        "path_type": "hardlink",
+        "sha256": "2e67c91fbd2ee5085909cec073fa4c97b7b4cfc0655e6034f5a3fb5a9ef6425d",
+        "sha256_in_prefix": "2e67c91fbd2ee5085909cec073fa4c97b7b4cfc0655e6034f5a3fb5a9ef6425d",
+        "size_in_bytes": 968
+      },
+      {
+        "_path": "Lib/ctypes/test/test_delattr.py",
+        "path_type": "hardlink",
+        "sha256": "90df922b1ebfa25185ccf01b3d22b82365986e4f45cae5499700e7ce54a4f695",
+        "sha256_in_prefix": "90df922b1ebfa25185ccf01b3d22b82365986e4f45cae5499700e7ce54a4f695",
+        "size_in_bytes": 533
+      },
+      {
+        "_path": "Lib/ctypes/test/test_errno.py",
+        "path_type": "hardlink",
+        "sha256": "76ca89b1f53e9174c99f1230ea2a1c52607565c7eff5a612a00e0fc117dde111",
+        "sha256_in_prefix": "76ca89b1f53e9174c99f1230ea2a1c52607565c7eff5a612a00e0fc117dde111",
+        "size_in_bytes": 2171
+      },
+      {
+        "_path": "Lib/ctypes/test/test_find.py",
+        "path_type": "hardlink",
+        "sha256": "fcb796bb763063491fbf846ba68ae05f0fb137ff214739c0fe164a5f2ee0b3c0",
+        "sha256_in_prefix": "fcb796bb763063491fbf846ba68ae05f0fb137ff214739c0fe164a5f2ee0b3c0",
+        "size_in_bytes": 4433
+      },
+      {
+        "_path": "Lib/ctypes/test/test_frombuffer.py",
+        "path_type": "hardlink",
+        "sha256": "d04ea0d55ac445635b331a4fccef38e9424e788495c360fe1da317c4f7b6a096",
+        "sha256_in_prefix": "d04ea0d55ac445635b331a4fccef38e9424e788495c360fe1da317c4f7b6a096",
+        "size_in_bytes": 5215
+      },
+      {
+        "_path": "Lib/ctypes/test/test_funcptr.py",
+        "path_type": "hardlink",
+        "sha256": "b41f2fdd13b3f4d8548a2f0b7e5d561c2e49f86e4df8107acb6a6b2ef421460f",
+        "sha256_in_prefix": "b41f2fdd13b3f4d8548a2f0b7e5d561c2e49f86e4df8107acb6a6b2ef421460f",
+        "size_in_bytes": 4026
+      },
+      {
+        "_path": "Lib/ctypes/test/test_functions.py",
+        "path_type": "hardlink",
+        "sha256": "7dd9334d30370b664b499b6e80226332f976492883fc3935fe5f2c4654897a57",
+        "sha256_in_prefix": "7dd9334d30370b664b499b6e80226332f976492883fc3935fe5f2c4654897a57",
+        "size_in_bytes": 12502
+      },
+      {
+        "_path": "Lib/ctypes/test/test_incomplete.py",
+        "path_type": "hardlink",
+        "sha256": "c66cb5a68165fd7e158d573adf12c2672d086d4b4e15515aaba654a45855f7c4",
+        "sha256_in_prefix": "c66cb5a68165fd7e158d573adf12c2672d086d4b4e15515aaba654a45855f7c4",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/ctypes/test/test_init.py",
+        "path_type": "hardlink",
+        "sha256": "1a23fe2e684f4fca33991b0b65e02a5959d045b59906bf3e2557a7f777f1def3",
+        "sha256_in_prefix": "1a23fe2e684f4fca33991b0b65e02a5959d045b59906bf3e2557a7f777f1def3",
+        "size_in_bytes": 1039
+      },
+      {
+        "_path": "Lib/ctypes/test/test_internals.py",
+        "path_type": "hardlink",
+        "sha256": "dc891b5d617d2a261527acfc1749ff8c402601f8bdc90f486ab6bfed45a0371f",
+        "sha256_in_prefix": "dc891b5d617d2a261527acfc1749ff8c402601f8bdc90f486ab6bfed45a0371f",
+        "size_in_bytes": 2631
+      },
+      {
+        "_path": "Lib/ctypes/test/test_keeprefs.py",
+        "path_type": "hardlink",
+        "sha256": "af92ac3f3e352a910dc13d15370b6cf53199509d176cd39d969f0570cb211049",
+        "sha256_in_prefix": "af92ac3f3e352a910dc13d15370b6cf53199509d176cd39d969f0570cb211049",
+        "size_in_bytes": 4058
+      },
+      {
+        "_path": "Lib/ctypes/test/test_libc.py",
+        "path_type": "hardlink",
+        "sha256": "f2694dc3211773272d31fdd1f0c27bf31e09adf9a7fd9ac42e4264e5bc26b3b3",
+        "sha256_in_prefix": "f2694dc3211773272d31fdd1f0c27bf31e09adf9a7fd9ac42e4264e5bc26b3b3",
+        "size_in_bytes": 1005
+      },
+      {
+        "_path": "Lib/ctypes/test/test_loading.py",
+        "path_type": "hardlink",
+        "sha256": "92be1af32b651f2befd3ba261f3a82d33ccab0c3c5a3508b327e02c113455995",
+        "sha256_in_prefix": "92be1af32b651f2befd3ba261f3a82d33ccab0c3c5a3508b327e02c113455995",
+        "size_in_bytes": 7064
+      },
+      {
+        "_path": "Lib/ctypes/test/test_macholib.py",
+        "path_type": "hardlink",
+        "sha256": "d7d7ff2706a6d1b1a843f3cb1f01da118d6c3032cda122c6989d4566bdcea547",
+        "sha256_in_prefix": "d7d7ff2706a6d1b1a843f3cb1f01da118d6c3032cda122c6989d4566bdcea547",
+        "size_in_bytes": 2121
+      },
+      {
+        "_path": "Lib/ctypes/test/test_memfunctions.py",
+        "path_type": "hardlink",
+        "sha256": "a723bfe187ec350b1c8d3cf1f8e7df3ca83a274b513b472a1833df6adf0a5420",
+        "sha256_in_prefix": "a723bfe187ec350b1c8d3cf1f8e7df3ca83a274b513b472a1833df6adf0a5420",
+        "size_in_bytes": 3293
+      },
+      {
+        "_path": "Lib/ctypes/test/test_numbers.py",
+        "path_type": "hardlink",
+        "sha256": "f62fd040bd9b01160cc9f10851d4f876f7f9aabcdf96130786ab248ea1835d2c",
+        "sha256_in_prefix": "f62fd040bd9b01160cc9f10851d4f876f7f9aabcdf96130786ab248ea1835d2c",
+        "size_in_bytes": 9526
+      },
+      {
+        "_path": "Lib/ctypes/test/test_objects.py",
+        "path_type": "hardlink",
+        "sha256": "b67b1cdcd568480e515eae06293d0d71dae3d2e4f0ad612cbe439673a84c164b",
+        "sha256_in_prefix": "b67b1cdcd568480e515eae06293d0d71dae3d2e4f0ad612cbe439673a84c164b",
+        "size_in_bytes": 1677
+      },
+      {
+        "_path": "Lib/ctypes/test/test_parameters.py",
+        "path_type": "hardlink",
+        "sha256": "b643d63921b91412a1000c87c75dcf66cfdabf52633241d5b86b51f4296326c1",
+        "sha256_in_prefix": "b643d63921b91412a1000c87c75dcf66cfdabf52633241d5b86b51f4296326c1",
+        "size_in_bytes": 9570
+      },
+      {
+        "_path": "Lib/ctypes/test/test_pep3118.py",
+        "path_type": "hardlink",
+        "sha256": "d8e35b9aa00030159f5907c4e0db059fb5d6fe5fafb498d27942f9c7a6c697d4",
+        "sha256_in_prefix": "d8e35b9aa00030159f5907c4e0db059fb5d6fe5fafb498d27942f9c7a6c697d4",
+        "size_in_bytes": 8516
+      },
+      {
+        "_path": "Lib/ctypes/test/test_pickling.py",
+        "path_type": "hardlink",
+        "sha256": "dac8e7f56da15fa162371b43c851d70844922c97c6d9908f5ad0fc3586aa4cd8",
+        "sha256_in_prefix": "dac8e7f56da15fa162371b43c851d70844922c97c6d9908f5ad0fc3586aa4cd8",
+        "size_in_bytes": 2218
+      },
+      {
+        "_path": "Lib/ctypes/test/test_pointers.py",
+        "path_type": "hardlink",
+        "sha256": "a82abf64174a8a572271a3e85d7cf31317aff8036928d7503ee5c786ffbcd1fc",
+        "sha256_in_prefix": "a82abf64174a8a572271a3e85d7cf31317aff8036928d7503ee5c786ffbcd1fc",
+        "size_in_bytes": 7239
+      },
+      {
+        "_path": "Lib/ctypes/test/test_prototypes.py",
+        "path_type": "hardlink",
+        "sha256": "bfdfb53c8cbae9a464105c4a3f38389c7721c9d1fd0333103b86e7c8071c9db2",
+        "sha256_in_prefix": "bfdfb53c8cbae9a464105c4a3f38389c7721c9d1fd0333103b86e7c8071c9db2",
+        "size_in_bytes": 6845
+      },
+      {
+        "_path": "Lib/ctypes/test/test_python_api.py",
+        "path_type": "hardlink",
+        "sha256": "363cf3a39d434bb1fdecfe4d8e872db161e5b11e5262eb8ae66a0acdc73fb720",
+        "sha256_in_prefix": "363cf3a39d434bb1fdecfe4d8e872db161e5b11e5262eb8ae66a0acdc73fb720",
+        "size_in_bytes": 2768
+      },
+      {
+        "_path": "Lib/ctypes/test/test_random_things.py",
+        "path_type": "hardlink",
+        "sha256": "0368da32f76a4c106cbeba3c92456947fbc68d1b012bc3762db1b5f9399e7be6",
+        "sha256_in_prefix": "0368da32f76a4c106cbeba3c92456947fbc68d1b012bc3762db1b5f9399e7be6",
+        "size_in_bytes": 2836
+      },
+      {
+        "_path": "Lib/ctypes/test/test_refcounts.py",
+        "path_type": "hardlink",
+        "sha256": "3bbde349f3e6413de32280d4e29d30273dadde1f9ee5bac32aa063e8a5a3670f",
+        "sha256_in_prefix": "3bbde349f3e6413de32280d4e29d30273dadde1f9ee5bac32aa063e8a5a3670f",
+        "size_in_bytes": 2576
+      },
+      {
+        "_path": "Lib/ctypes/test/test_repr.py",
+        "path_type": "hardlink",
+        "sha256": "a89661e8555d05531985619fa54a16eccda0e15e50bc11dcc6ee9df9b3c590cd",
+        "sha256_in_prefix": "a89661e8555d05531985619fa54a16eccda0e15e50bc11dcc6ee9df9b3c590cd",
+        "size_in_bytes": 842
+      },
+      {
+        "_path": "Lib/ctypes/test/test_returnfuncptrs.py",
+        "path_type": "hardlink",
+        "sha256": "c2f3c65d439622b1f44ba6cb54a14bfb9bb9fec4a1ca47a930f067c307f32481",
+        "sha256_in_prefix": "c2f3c65d439622b1f44ba6cb54a14bfb9bb9fec4a1ca47a930f067c307f32481",
+        "size_in_bytes": 2893
+      },
+      {
+        "_path": "Lib/ctypes/test/test_simplesubclasses.py",
+        "path_type": "hardlink",
+        "sha256": "a1f30fe454d29ec7d61e9aff7c02bca3072ab2dede632a98e0d68985b025d402",
+        "sha256_in_prefix": "a1f30fe454d29ec7d61e9aff7c02bca3072ab2dede632a98e0d68985b025d402",
+        "size_in_bytes": 1289
+      },
+      {
+        "_path": "Lib/ctypes/test/test_sizes.py",
+        "path_type": "hardlink",
+        "sha256": "ebebf011281a5c1fb7f76ccc40aad2da2aafdc96e6360e8c5f5e62d0c56d11bd",
+        "sha256_in_prefix": "ebebf011281a5c1fb7f76ccc40aad2da2aafdc96e6360e8c5f5e62d0c56d11bd",
+        "size_in_bytes": 804
+      },
+      {
+        "_path": "Lib/ctypes/test/test_slicing.py",
+        "path_type": "hardlink",
+        "sha256": "f743c7b22a0dc8b4927a6d6ddba218bbe5e954f0d9f7089fdc4e00d6378a1c2d",
+        "sha256_in_prefix": "f743c7b22a0dc8b4927a6d6ddba218bbe5e954f0d9f7089fdc4e00d6378a1c2d",
+        "size_in_bytes": 6025
+      },
+      {
+        "_path": "Lib/ctypes/test/test_stringptr.py",
+        "path_type": "hardlink",
+        "sha256": "76c576c3fab33e040af706bfa799e42fd67fd82457af7627ebcf642a42b83b54",
+        "sha256_in_prefix": "76c576c3fab33e040af706bfa799e42fd67fd82457af7627ebcf642a42b83b54",
+        "size_in_bytes": 2598
+      },
+      {
+        "_path": "Lib/ctypes/test/test_strings.py",
+        "path_type": "hardlink",
+        "sha256": "d7d65444b140db8b2f2f415c8440e220e322ec865c974d9c74fa8ce03908bba0",
+        "sha256_in_prefix": "d7d65444b140db8b2f2f415c8440e220e322ec865c974d9c74fa8ce03908bba0",
+        "size_in_bytes": 7303
+      },
+      {
+        "_path": "Lib/ctypes/test/test_struct_fields.py",
+        "path_type": "hardlink",
+        "sha256": "42e69f54ebd21bbad418f805c8bf79e2b5370f497b894bf4a0daee51ea758142",
+        "sha256_in_prefix": "42e69f54ebd21bbad418f805c8bf79e2b5370f497b894bf4a0daee51ea758142",
+        "size_in_bytes": 2421
+      },
+      {
+        "_path": "Lib/ctypes/test/test_structures.py",
+        "path_type": "hardlink",
+        "sha256": "68657ed0c41735b84dae161e65391cc70272930892729195e64efc1208cf4cec",
+        "sha256_in_prefix": "68657ed0c41735b84dae161e65391cc70272930892729195e64efc1208cf4cec",
+        "size_in_bytes": 27432
+      },
+      {
+        "_path": "Lib/ctypes/test/test_unaligned_structures.py",
+        "path_type": "hardlink",
+        "sha256": "0c15a8e79b9fe5edfb0df4be28827dc628a32a9dc948297e16dbf183583bd453",
+        "sha256_in_prefix": "0c15a8e79b9fe5edfb0df4be28827dc628a32a9dc948297e16dbf183583bd453",
+        "size_in_bytes": 1140
+      },
+      {
+        "_path": "Lib/ctypes/test/test_unicode.py",
+        "path_type": "hardlink",
+        "sha256": "0d385d2cc2fa54d7063531169cc49c4105aa1463e54e298afcbc2f9ddb8f2675",
+        "sha256_in_prefix": "0d385d2cc2fa54d7063531169cc49c4105aa1463e54e298afcbc2f9ddb8f2675",
+        "size_in_bytes": 1997
+      },
+      {
+        "_path": "Lib/ctypes/test/test_values.py",
+        "path_type": "hardlink",
+        "sha256": "6fcefcebae5a1b1d9d32f60b132a5a29da8fedbbb142e6fe9bb00f99dd1f3d79",
+        "sha256_in_prefix": "6fcefcebae5a1b1d9d32f60b132a5a29da8fedbbb142e6fe9bb00f99dd1f3d79",
+        "size_in_bytes": 3871
+      },
+      {
+        "_path": "Lib/ctypes/test/test_varsize_struct.py",
+        "path_type": "hardlink",
+        "sha256": "c7d463aa0ee94baa8aab42a1e7c53a9b5547110fffd1a85c30acc0a952bcb216",
+        "sha256_in_prefix": "c7d463aa0ee94baa8aab42a1e7c53a9b5547110fffd1a85c30acc0a952bcb216",
+        "size_in_bytes": 1842
+      },
+      {
+        "_path": "Lib/ctypes/test/test_win32.py",
+        "path_type": "hardlink",
+        "sha256": "05490ad5f19e2919a1dedda2a7ddb4a77389cf78f56293c97fc1343724690ac2",
+        "sha256_in_prefix": "05490ad5f19e2919a1dedda2a7ddb4a77389cf78f56293c97fc1343724690ac2",
+        "size_in_bytes": 5027
+      },
+      {
+        "_path": "Lib/ctypes/test/test_wintypes.py",
+        "path_type": "hardlink",
+        "sha256": "d535399195f0b6383004f5dfd3bc309b4ff2f249f6cb99080189f7d7e55c4ef5",
+        "sha256_in_prefix": "d535399195f0b6383004f5dfd3bc309b4ff2f249f6cb99080189f7d7e55c4ef5",
+        "size_in_bytes": 1397
+      },
+      {
+        "_path": "Lib/ctypes/util.py",
+        "path_type": "hardlink",
+        "sha256": "2c256f4c754f9e085b3a86d22a307ceb8ec455a1d351b88fca517e6ffbfa13f6",
+        "sha256_in_prefix": "2c256f4c754f9e085b3a86d22a307ceb8ec455a1d351b88fca517e6ffbfa13f6",
+        "size_in_bytes": 14856
+      },
+      {
+        "_path": "Lib/ctypes/wintypes.py",
+        "path_type": "hardlink",
+        "sha256": "c8f29e6cb1b05223e423391242f671381546130acae1fd7baafb65ba849f2a00",
+        "sha256_in_prefix": "c8f29e6cb1b05223e423391242f671381546130acae1fd7baafb65ba849f2a00",
+        "size_in_bytes": 5628
+      },
+      {
+        "_path": "Lib/curses/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0",
+        "sha256_in_prefix": "d8730e360dd00ec046bdd85cae41fe83c907c6ae3716a964158fce8f31ab28b0",
+        "size_in_bytes": 3369
+      },
+      {
+        "_path": "Lib/curses/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de040c0ad00aa6b9726a8ff9916b8be1f923e25c1aef6f9524aeb29bcf99876d",
+        "sha256_in_prefix": "de040c0ad00aa6b9726a8ff9916b8be1f923e25c1aef6f9524aeb29bcf99876d",
+        "size_in_bytes": 1844
+      },
+      {
+        "_path": "Lib/curses/__pycache__/ascii.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d5eb3e80ff95e13519fa928c5b32e6b4719474f3a40aad3456ab1c05fe36c49e",
+        "sha256_in_prefix": "d5eb3e80ff95e13519fa928c5b32e6b4719474f3a40aad3456ab1c05fe36c49e",
+        "size_in_bytes": 3816
+      },
+      {
+        "_path": "Lib/curses/__pycache__/has_key.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "452d43758e50f13500b0bf2d3238a1a0b3fddc200da4807b787faf38e4951b52",
+        "sha256_in_prefix": "452d43758e50f13500b0bf2d3238a1a0b3fddc200da4807b787faf38e4951b52",
+        "size_in_bytes": 4272
+      },
+      {
+        "_path": "Lib/curses/__pycache__/panel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cd08152093aa835649f99b277a04bf85dd6389ed9d2b78010708890ed70c61b2",
+        "sha256_in_prefix": "cd08152093aa835649f99b277a04bf85dd6389ed9d2b78010708890ed70c61b2",
+        "size_in_bytes": 208
+      },
+      {
+        "_path": "Lib/curses/__pycache__/textpad.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f734c6cafdc5ea5cb30788f9b1633b7308f797f68e60bcff5c78f186c206f458",
+        "sha256_in_prefix": "f734c6cafdc5ea5cb30788f9b1633b7308f797f68e60bcff5c78f186c206f458",
+        "size_in_bytes": 5890
+      },
+      {
+        "_path": "Lib/curses/ascii.py",
+        "path_type": "hardlink",
+        "sha256": "cf0137c2143c5e5bea2ccd25bfc61f3a274c5d8fdab3bc4c2c7329412ce7b656",
+        "sha256_in_prefix": "cf0137c2143c5e5bea2ccd25bfc61f3a274c5d8fdab3bc4c2c7329412ce7b656",
+        "size_in_bytes": 2547
+      },
+      {
+        "_path": "Lib/curses/has_key.py",
+        "path_type": "hardlink",
+        "sha256": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3",
+        "sha256_in_prefix": "15a052812d9ae80124bb25b3f5b9ffae38e2b03073774e163abf3d773140cfb3",
+        "size_in_bytes": 5634
+      },
+      {
+        "_path": "Lib/curses/panel.py",
+        "path_type": "hardlink",
+        "sha256": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7",
+        "sha256_in_prefix": "13ef404a30da1825a612ca3e453db88c305d45deef4441c4c9e2ef7ee0ef50c7",
+        "size_in_bytes": 87
+      },
+      {
+        "_path": "Lib/curses/textpad.py",
+        "path_type": "hardlink",
+        "sha256": "bbc4634b3396bb6aa89f186206b9e236047e443ffd727116f45b537f4dce0759",
+        "sha256_in_prefix": "bbc4634b3396bb6aa89f186206b9e236047e443ffd727116f45b537f4dce0759",
+        "size_in_bytes": 7657
+      },
+      {
+        "_path": "Lib/dataclasses.py",
+        "path_type": "hardlink",
+        "sha256": "85bc57441fb90ad19952d0037ebc4166ca4ce1469ff5a6ef11b1237cabae87f6",
+        "sha256_in_prefix": "85bc57441fb90ad19952d0037ebc4166ca4ce1469ff5a6ef11b1237cabae87f6",
+        "size_in_bytes": 49586
+      },
+      {
+        "_path": "Lib/datetime.py",
+        "path_type": "hardlink",
+        "sha256": "74c063b5f7c9e97049b0fc6a5027d222a584abf51fff6d25548abfee30004747",
+        "sha256_in_prefix": "74c063b5f7c9e97049b0fc6a5027d222a584abf51fff6d25548abfee30004747",
+        "size_in_bytes": 89177
+      },
+      {
+        "_path": "Lib/dbm/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "930cdedcd5887bdf70477c541d73b54797c232d90dce149ab5b135331f04ec16",
+        "sha256_in_prefix": "930cdedcd5887bdf70477c541d73b54797c232d90dce149ab5b135331f04ec16",
+        "size_in_bytes": 5839
+      },
+      {
+        "_path": "Lib/dbm/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "92c4b0f4a70a19726394cc6791ed3058e89db2d656167968f5d6e2ed0c6b7bd1",
+        "sha256_in_prefix": "92c4b0f4a70a19726394cc6791ed3058e89db2d656167968f5d6e2ed0c6b7bd1",
+        "size_in_bytes": 4216
+      },
+      {
+        "_path": "Lib/dbm/__pycache__/dumb.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4caffc2367afb30644e510368347c7ee7089d3124ad6628c720575f426c4e544",
+        "sha256_in_prefix": "4caffc2367afb30644e510368347c7ee7089d3124ad6628c720575f426c4e544",
+        "size_in_bytes": 7898
+      },
+      {
+        "_path": "Lib/dbm/__pycache__/gnu.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "84f02b082191176ca076e3fbe0efa6bb9fda96a83326aac7b7e7af9b3e96a7d5",
+        "sha256_in_prefix": "84f02b082191176ca076e3fbe0efa6bb9fda96a83326aac7b7e7af9b3e96a7d5",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "Lib/dbm/__pycache__/ndbm.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "898bc661675a66f01be8a0e1bfcd638cc320968800025e9a215973524fed9f95",
+        "sha256_in_prefix": "898bc661675a66f01be8a0e1bfcd638cc320968800025e9a215973524fed9f95",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "Lib/dbm/dumb.py",
+        "path_type": "hardlink",
+        "sha256": "eec69824f4a1cfa02e23766eecc48339b09c5a08b0099063d3f0311c252e9700",
+        "sha256_in_prefix": "eec69824f4a1cfa02e23766eecc48339b09c5a08b0099063d3f0311c252e9700",
+        "size_in_bytes": 11536
+      },
+      {
+        "_path": "Lib/dbm/gnu.py",
+        "path_type": "hardlink",
+        "sha256": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778",
+        "sha256_in_prefix": "36cd4904f50e00c4df4ad9d450b3970e150957425f47c00cf979ba73eff49778",
+        "size_in_bytes": 72
+      },
+      {
+        "_path": "Lib/dbm/ndbm.py",
+        "path_type": "hardlink",
+        "sha256": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b",
+        "sha256_in_prefix": "1bcc2d9b2fad1901f3421a174eeecb5b8ccc6763283b87bbe0705b404c71904b",
+        "size_in_bytes": 70
+      },
+      {
+        "_path": "Lib/decimal.py",
+        "path_type": "hardlink",
+        "sha256": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81",
+        "sha256_in_prefix": "000c00bad31d126b054c6ec7f3e02b27c0f9a4d579f987d3c4f879cee1bacb81",
+        "size_in_bytes": 320
+      },
+      {
+        "_path": "Lib/difflib.py",
+        "path_type": "hardlink",
+        "sha256": "5ecbbaaa838dbb2fdafc41280a281eeb7deeae05d889c31ebbf0d18d4cf66c3d",
+        "sha256_in_prefix": "5ecbbaaa838dbb2fdafc41280a281eeb7deeae05d889c31ebbf0d18d4cf66c3d",
+        "size_in_bytes": 83307
+      },
+      {
+        "_path": "Lib/dis.py",
+        "path_type": "hardlink",
+        "sha256": "12f8cf82811f5dda498fa3c4852af458d1a4915ccf779b4badad08407b8e15e9",
+        "sha256_in_prefix": "12f8cf82811f5dda498fa3c4852af458d1a4915ccf779b4badad08407b8e15e9",
+        "size_in_bytes": 20570
+      },
+      {
+        "_path": "Lib/distutils/README",
+        "path_type": "hardlink",
+        "sha256": "8d19071886238eda514e96a7ab1c17d6d8c26ae628c4ddbc8ecc5329fd9d8000",
+        "sha256_in_prefix": "8d19071886238eda514e96a7ab1c17d6d8c26ae628c4ddbc8ecc5329fd9d8000",
+        "size_in_bytes": 244
+      },
+      {
+        "_path": "Lib/distutils/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "6e2c4b7ba17bd010296d63aab23e13145c3da3552700bd09032489db88eee0af",
+        "sha256_in_prefix": "6e2c4b7ba17bd010296d63aab23e13145c3da3552700bd09032489db88eee0af",
+        "size_in_bytes": 236
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3d01635f4447f389f610188cbe39a48b41d9a59cc77defad6c7990913b8983de",
+        "sha256_in_prefix": "3d01635f4447f389f610188cbe39a48b41d9a59cc77defad6c7990913b8983de",
+        "size_in_bytes": 369
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/_msvccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9b3dd18a52108c252708cd7feff01088147daa1d3f717ef3e9d02c44a33dd514",
+        "sha256_in_prefix": "9b3dd18a52108c252708cd7feff01088147daa1d3f717ef3e9d02c44a33dd514",
+        "size_in_bytes": 12899
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/archive_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9d8ae2bf47b02f8aceb5e294a3d9c10418d5a6dceaab455f19298145983cac24",
+        "sha256_in_prefix": "9d8ae2bf47b02f8aceb5e294a3d9c10418d5a6dceaab455f19298145983cac24",
+        "size_in_bytes": 6570
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/bcppcompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c54191c6740a67a0447c7e03fe5b8dffc913ff13f65483d58791368951b29f4f",
+        "sha256_in_prefix": "c54191c6740a67a0447c7e03fe5b8dffc913ff13f65483d58791368951b29f4f",
+        "size_in_bytes": 6481
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/ccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c80d462aedf85e0093e189e221f0b65011f5d00bc57d87f08f0bfdd077824c07",
+        "sha256_in_prefix": "c80d462aedf85e0093e189e221f0b65011f5d00bc57d87f08f0bfdd077824c07",
+        "size_in_bytes": 33171
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/cmd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d12d7dc9ed9e2da9fb41774c6d9c95eceaf02a8cd8358eb07d4f5ef796f58b8f",
+        "sha256_in_prefix": "d12d7dc9ed9e2da9fb41774c6d9c95eceaf02a8cd8358eb07d4f5ef796f58b8f",
+        "size_in_bytes": 13909
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/config.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "675e73ed3e2c205f65333209be4417d7e877fe309980a96d42c867d0f8d5285a",
+        "sha256_in_prefix": "675e73ed3e2c205f65333209be4417d7e877fe309980a96d42c867d0f8d5285a",
+        "size_in_bytes": 3512
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/core.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1d1f159c998b57f9fa4e76a1aed3121f5c16e7e6272a8efe84f9911290bf02e6",
+        "sha256_in_prefix": "1d1f159c998b57f9fa4e76a1aed3121f5c16e7e6272a8efe84f9911290bf02e6",
+        "size_in_bytes": 6637
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/cygwinccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7126cab39ead1275ae8178e1f38b923b1a691b12385caef19ca9ebd034f0c2e9",
+        "sha256_in_prefix": "7126cab39ead1275ae8178e1f38b923b1a691b12385caef19ca9ebd034f0c2e9",
+        "size_in_bytes": 8619
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/debug.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d51ad2a2eca8fdcdb6b5a4583fa8671a12587ebcf0fb858daa60423ec7e84d0b",
+        "sha256_in_prefix": "d51ad2a2eca8fdcdb6b5a4583fa8671a12587ebcf0fb858daa60423ec7e84d0b",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/dep_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1fc43becfaa26806030611e448f0a9185b92faeb75f49e8ddf2e775daed4b8e6",
+        "sha256_in_prefix": "1fc43becfaa26806030611e448f0a9185b92faeb75f49e8ddf2e775daed4b8e6",
+        "size_in_bytes": 2699
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/dir_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "14c184455b9ecfaebd3625cbbe6b4dbcadfe3f104bf9e22c26c67d7617901d0f",
+        "sha256_in_prefix": "14c184455b9ecfaebd3625cbbe6b4dbcadfe3f104bf9e22c26c67d7617901d0f",
+        "size_in_bytes": 5800
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/dist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c2296dfa4bd0563ec06145020ead18ff813f3466f445af43fd7df3334961f2e8",
+        "sha256_in_prefix": "c2296dfa4bd0563ec06145020ead18ff813f3466f445af43fd7df3334961f2e8",
+        "size_in_bytes": 34331
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/errors.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5dce3195d329f0e40f9e4623bcca6fa76aaffaa0c1ed344af3b31685b396631b",
+        "sha256_in_prefix": "5dce3195d329f0e40f9e4623bcca6fa76aaffaa0c1ed344af3b31685b396631b",
+        "size_in_bytes": 5235
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/extension.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a2d777b7e08ce9a8e474d8f52e64f3a86d0aab7654d33fd87232f67327dcbe7e",
+        "sha256_in_prefix": "a2d777b7e08ce9a8e474d8f52e64f3a86d0aab7654d33fd87232f67327dcbe7e",
+        "size_in_bytes": 6900
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/fancy_getopt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7510a29ac15cade79259e931624340f6359cf67293a212836d6a1aec48dd8c1b",
+        "sha256_in_prefix": "7510a29ac15cade79259e931624340f6359cf67293a212836d6a1aec48dd8c1b",
+        "size_in_bytes": 10608
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/file_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "34539e723c6a1f6907759eeda072927ce62e32fc12c6c81d47ff56c6cf2fe590",
+        "sha256_in_prefix": "34539e723c6a1f6907759eeda072927ce62e32fc12c6c81d47ff56c6cf2fe590",
+        "size_in_bytes": 5966
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/filelist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ed94d704e8c091a530b76f1821bb1bcc9cd28295b20b353331187bf2dd33bde3",
+        "sha256_in_prefix": "ed94d704e8c091a530b76f1821bb1bcc9cd28295b20b353331187bf2dd33bde3",
+        "size_in_bytes": 9818
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/log.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "59c0f1c24c1f6aaa6fc0203b8ed334da43f9165357dd7c831d1b2eb0c9533625",
+        "sha256_in_prefix": "59c0f1c24c1f6aaa6fc0203b8ed334da43f9165357dd7c831d1b2eb0c9533625",
+        "size_in_bytes": 2298
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/msvc9compiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1c6237472c9389c9f21c5ba62a05d1bbc0505d44499977f037cf56338d253718",
+        "sha256_in_prefix": "1c6237472c9389c9f21c5ba62a05d1bbc0505d44499977f037cf56338d253718",
+        "size_in_bytes": 17495
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/msvccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fa674baafa3b7af0a17c7d0b99b971b352e2cc9c14d425b7a2e399839244b22e",
+        "sha256_in_prefix": "fa674baafa3b7af0a17c7d0b99b971b352e2cc9c14d425b7a2e399839244b22e",
+        "size_in_bytes": 14690
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/spawn.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b45804d965ba31fba66d1e34517771e676b068456c89ebc5aa16e9f2b200eae0",
+        "sha256_in_prefix": "b45804d965ba31fba66d1e34517771e676b068456c89ebc5aa16e9f2b200eae0",
+        "size_in_bytes": 3424
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/sysconfig.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5d05e20f957e4194c52a1cd78b45d61df3cc725cb5a2ea96ee61a3ed1d95a2e3",
+        "sha256_in_prefix": "5d05e20f957e4194c52a1cd78b45d61df3cc725cb5a2ea96ee61a3ed1d95a2e3",
+        "size_in_bytes": 12174
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/text_file.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f61e8572f895e6dba8e062df87409dd29b9b9e0e4398c0288c918a10f885cc56",
+        "sha256_in_prefix": "f61e8572f895e6dba8e062df87409dd29b9b9e0e4398c0288c918a10f885cc56",
+        "size_in_bytes": 8424
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/unixccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a83419b44a915a2edfea6c67ead6f0bb9083f74c15a96e7d32881d829fcf73b5",
+        "sha256_in_prefix": "a83419b44a915a2edfea6c67ead6f0bb9083f74c15a96e7d32881d829fcf73b5",
+        "size_in_bytes": 6935
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0c99c3060d1bb06f7419e346981a090d9f5f038f4a345c2c1a5c1ebfd119317a",
+        "sha256_in_prefix": "0c99c3060d1bb06f7419e346981a090d9f5f038f4a345c2c1a5c1ebfd119317a",
+        "size_in_bytes": 15573
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "84f88e57de08c8d807267f490e8b19857fbc34a97a599442b7541e4563ccdf7f",
+        "sha256_in_prefix": "84f88e57de08c8d807267f490e8b19857fbc34a97a599442b7541e4563ccdf7f",
+        "size_in_bytes": 7324
+      },
+      {
+        "_path": "Lib/distutils/__pycache__/versionpredicate.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "15c34ba3f3ebc8325cf47240ea0c885b6bd891a37a948fc0e334efd36b087918",
+        "sha256_in_prefix": "15c34ba3f3ebc8325cf47240ea0c885b6bd891a37a948fc0e334efd36b087918",
+        "size_in_bytes": 5108
+      },
+      {
+        "_path": "Lib/distutils/_msvccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "9b910917fbabe543d127588f5e091c46c4b293b189f49bfbca955acb77772b79",
+        "sha256_in_prefix": "9b910917fbabe543d127588f5e091c46c4b293b189f49bfbca955acb77772b79",
+        "size_in_bytes": 20362
+      },
+      {
+        "_path": "Lib/distutils/archive_util.py",
+        "path_type": "hardlink",
+        "sha256": "a96fae886c187b14ef2b97be8927a5ff7d43b21c7e0aa4da9cd3caeac9f07fdf",
+        "sha256_in_prefix": "a96fae886c187b14ef2b97be8927a5ff7d43b21c7e0aa4da9cd3caeac9f07fdf",
+        "size_in_bytes": 8572
+      },
+      {
+        "_path": "Lib/distutils/bcppcompiler.py",
+        "path_type": "hardlink",
+        "sha256": "3890d5a425265fa1fcbffee5575ce27d5d5f731f760abd9d862521ebdf3d5092",
+        "sha256_in_prefix": "3890d5a425265fa1fcbffee5575ce27d5d5f731f760abd9d862521ebdf3d5092",
+        "size_in_bytes": 14894
+      },
+      {
+        "_path": "Lib/distutils/ccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "194146bc2645bafe0d34d90d6837958779de804b21178b3e1a3da651bbbccffb",
+        "sha256_in_prefix": "194146bc2645bafe0d34d90d6837958779de804b21178b3e1a3da651bbbccffb",
+        "size_in_bytes": 47418
+      },
+      {
+        "_path": "Lib/distutils/cmd.py",
+        "path_type": "hardlink",
+        "sha256": "79ca3a2c0194b686cbb8f69fba19a02a09304512ff598f0a27861e0c21e9725b",
+        "sha256_in_prefix": "79ca3a2c0194b686cbb8f69fba19a02a09304512ff598f0a27861e0c21e9725b",
+        "size_in_bytes": 18079
+      },
+      {
+        "_path": "Lib/distutils/command/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "d9303eae5343973788f9cb1b5875c58c60fcb8e62a00b31fc963a14f8f670ba8",
+        "sha256_in_prefix": "d9303eae5343973788f9cb1b5875c58c60fcb8e62a00b31fc963a14f8f670ba8",
+        "size_in_bytes": 799
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d0f5646920e25fed066fc25087256e0d8f8ea263f2382d4df9b95029ce22380f",
+        "sha256_in_prefix": "d0f5646920e25fed066fc25087256e0d8f8ea263f2382d4df9b95029ce22380f",
+        "size_in_bytes": 458
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/bdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "18a51d0c2ed7fd2c91fca0109577ccb0bacb174507cdad43548838bd23e30cdc",
+        "sha256_in_prefix": "18a51d0c2ed7fd2c91fca0109577ccb0bacb174507cdad43548838bd23e30cdc",
+        "size_in_bytes": 3588
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/bdist_dumb.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b7dd8bcaaf2eda2cc7e4ccf85a2cfbb773828ab3788d1040e2f055b0dbc33097",
+        "sha256_in_prefix": "b7dd8bcaaf2eda2cc7e4ccf85a2cfbb773828ab3788d1040e2f055b0dbc33097",
+        "size_in_bytes": 3571
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/bdist_msi.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9cd21281424a0a9e641ae3c61f2adbc931470024b83e3826a9bc2576a1cbf27e",
+        "sha256_in_prefix": "9cd21281424a0a9e641ae3c61f2adbc931470024b83e3826a9bc2576a1cbf27e",
+        "size_in_bytes": 19753
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/bdist_rpm.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d10662bb5331cc66c6b2e45db1f12a9dc76b0d3e199d1715a6ef7d8a266f270f",
+        "sha256_in_prefix": "d10662bb5331cc66c6b2e45db1f12a9dc76b0d3e199d1715a6ef7d8a266f270f",
+        "size_in_bytes": 12208
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/bdist_wininst.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6ca9564613a5cf247312b68a4b72fc8595082fcd75c61d5d28a9fe0b8c4fac2b",
+        "sha256_in_prefix": "6ca9564613a5cf247312b68a4b72fc8595082fcd75c61d5d28a9fe0b8c4fac2b",
+        "size_in_bytes": 8528
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/build.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "76a80f3f41a42c484150b73ae057d0a5b5a17e01953f6ea46ecbe6f8fa991d94",
+        "sha256_in_prefix": "76a80f3f41a42c484150b73ae057d0a5b5a17e01953f6ea46ecbe6f8fa991d94",
+        "size_in_bytes": 3864
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/build_clib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "793c5f57833b0900593ea2537750bf58736df162f6e382b45e258f21f7cfb52e",
+        "sha256_in_prefix": "793c5f57833b0900593ea2537750bf58736df162f6e382b45e258f21f7cfb52e",
+        "size_in_bytes": 4783
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/build_ext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "91208251416176e7a66f3daab6932f68bcc6211989d7d2d851ed16014d9aeb55",
+        "sha256_in_prefix": "91208251416176e7a66f3daab6932f68bcc6211989d7d2d851ed16014d9aeb55",
+        "size_in_bytes": 16174
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/build_py.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9961e2d224a71057ddc7b942b09423e96fdf3ac98a8273952ebd0b9153dd9d60",
+        "sha256_in_prefix": "9961e2d224a71057ddc7b942b09423e96fdf3ac98a8273952ebd0b9153dd9d60",
+        "size_in_bytes": 10416
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/build_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7aa7b14f39e43781311cd851ebf35e4c662a97d70c4e7bdffe9b84503859b3d6",
+        "sha256_in_prefix": "7aa7b14f39e43781311cd851ebf35e4c662a97d70c4e7bdffe9b84503859b3d6",
+        "size_in_bytes": 4313
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/check.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d24fcaada21cdf565e6dd4c71764b88d11bae3ef9c6c1e344572eff83a16171f",
+        "sha256_in_prefix": "d24fcaada21cdf565e6dd4c71764b88d11bae3ef9c6c1e344572eff83a16171f",
+        "size_in_bytes": 4891
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/clean.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "56560cf8f0a047ea76ae68c677f90d95ab482ca896f49de2d651076ae007de2e",
+        "sha256_in_prefix": "56560cf8f0a047ea76ae68c677f90d95ab482ca896f49de2d651076ae007de2e",
+        "size_in_bytes": 2065
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/config.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ed61a8cb571f0f2ac53f9fdd7fd529885a30e0b429ae5b8b8ec510b7a0b5eb09",
+        "sha256_in_prefix": "ed61a8cb571f0f2ac53f9fdd7fd529885a30e0b429ae5b8b8ec510b7a0b5eb09",
+        "size_in_bytes": 10195
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "841dd0d92b6feb24d37cda8b2fffb9519569d95c1296ea4112817967f163dc97",
+        "sha256_in_prefix": "841dd0d92b6feb24d37cda8b2fffb9519569d95c1296ea4112817967f163dc97",
+        "size_in_bytes": 13523
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/install_data.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e6ecfc74aa1d44c3462bea7782767ab34804dc063246da3e6c817162e636b221",
+        "sha256_in_prefix": "e6ecfc74aa1d44c3462bea7782767ab34804dc063246da3e6c817162e636b221",
+        "size_in_bytes": 2268
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/install_egg_info.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d73d6edafcc9edb6be2ddf2f038e09d0fc0451599ba973a681463dc2bae1fcf",
+        "sha256_in_prefix": "2d73d6edafcc9edb6be2ddf2f038e09d0fc0451599ba973a681463dc2bae1fcf",
+        "size_in_bytes": 3003
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/install_headers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "da27f400808434cdf0b5b0a9aee74196c776d9f673b2a96ac250900a34aa9177",
+        "sha256_in_prefix": "da27f400808434cdf0b5b0a9aee74196c776d9f673b2a96ac250900a34aa9177",
+        "size_in_bytes": 1693
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/install_lib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "10451f27d46141f532dd22aa1e276abecf99aeff7430fbb21236d74fc4da47ae",
+        "sha256_in_prefix": "10451f27d46141f532dd22aa1e276abecf99aeff7430fbb21236d74fc4da47ae",
+        "size_in_bytes": 5065
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/install_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "baec99dc44ed37b26002c3ab07e6769888fa58b4720b63de7feacce3495a5cdb",
+        "sha256_in_prefix": "baec99dc44ed37b26002c3ab07e6769888fa58b4720b63de7feacce3495a5cdb",
+        "size_in_bytes": 2116
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/register.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e90ec100dff92686afb4d506968945cd81f96cc1d5c344085504f3a400bc59cc",
+        "sha256_in_prefix": "e90ec100dff92686afb4d506968945cd81f96cc1d5c344085504f3a400bc59cc",
+        "size_in_bytes": 8436
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/sdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "20c264eb4b9f05133efe693a541b50a1a55f749a16b09e5392cc48a2a6fe3160",
+        "sha256_in_prefix": "20c264eb4b9f05133efe693a541b50a1a55f749a16b09e5392cc48a2a6fe3160",
+        "size_in_bytes": 14463
+      },
+      {
+        "_path": "Lib/distutils/command/__pycache__/upload.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "94ed98f6d8121d2f9610832facdc7d10fb440e1d99a10033312aed416d3b2f6c",
+        "sha256_in_prefix": "94ed98f6d8121d2f9610832facdc7d10fb440e1d99a10033312aed416d3b2f6c",
+        "size_in_bytes": 5212
+      },
+      {
+        "_path": "Lib/distutils/command/bdist.py",
+        "path_type": "hardlink",
+        "sha256": "db3e1eb9d465fe7ee6de51bd95e2f4218a9eb386ec9bc7347f17d9ba269f8cc8",
+        "sha256_in_prefix": "db3e1eb9d465fe7ee6de51bd95e2f4218a9eb386ec9bc7347f17d9ba269f8cc8",
+        "size_in_bytes": 5562
+      },
+      {
+        "_path": "Lib/distutils/command/bdist_dumb.py",
+        "path_type": "hardlink",
+        "sha256": "053babf63708a69c8fecf89abe37ec93b623125aafc5e60eda7a54c8f3ce7a47",
+        "sha256_in_prefix": "053babf63708a69c8fecf89abe37ec93b623125aafc5e60eda7a54c8f3ce7a47",
+        "size_in_bytes": 4913
+      },
+      {
+        "_path": "Lib/distutils/command/bdist_msi.py",
+        "path_type": "hardlink",
+        "sha256": "11515060dfd7f84c5e78ff2099d57d25c20db2e506b0b254cfd69f314d11b7c7",
+        "sha256_in_prefix": "11515060dfd7f84c5e78ff2099d57d25c20db2e506b0b254cfd69f314d11b7c7",
+        "size_in_bytes": 35579
+      },
+      {
+        "_path": "Lib/distutils/command/bdist_rpm.py",
+        "path_type": "hardlink",
+        "sha256": "8233b0db61a10d26dcab46ddab6e5c4dbfa7e875969b46d284b41a77f9a42789",
+        "sha256_in_prefix": "8233b0db61a10d26dcab46ddab6e5c4dbfa7e875969b46d284b41a77f9a42789",
+        "size_in_bytes": 21537
+      },
+      {
+        "_path": "Lib/distutils/command/bdist_wininst.py",
+        "path_type": "hardlink",
+        "sha256": "88695a23e55f1251ce9de79ccca1d69d23796b5d3eec831c25a5ee47599d4b77",
+        "sha256_in_prefix": "88695a23e55f1251ce9de79ccca1d69d23796b5d3eec831c25a5ee47599d4b77",
+        "size_in_bytes": 16030
+      },
+      {
+        "_path": "Lib/distutils/command/build.py",
+        "path_type": "hardlink",
+        "sha256": "d753724765005336a5ae44d9da98740401c55850b68ed4ac37b808685f8d0b4f",
+        "sha256_in_prefix": "d753724765005336a5ae44d9da98740401c55850b68ed4ac37b808685f8d0b4f",
+        "size_in_bytes": 5767
+      },
+      {
+        "_path": "Lib/distutils/command/build_clib.py",
+        "path_type": "hardlink",
+        "sha256": "6e05531e1dbc78b400d86930ebc6a602977f8fba90057e0c4c8fb34ef00afc9e",
+        "sha256_in_prefix": "6e05531e1dbc78b400d86930ebc6a602977f8fba90057e0c4c8fb34ef00afc9e",
+        "size_in_bytes": 8022
+      },
+      {
+        "_path": "Lib/distutils/command/build_ext.py",
+        "path_type": "hardlink",
+        "sha256": "30c24f0b11e57fdae05248b39f82a3abdbd878011fc72a9fabc5ec4c4f84a563",
+        "sha256_in_prefix": "30c24f0b11e57fdae05248b39f82a3abdbd878011fc72a9fabc5ec4c4f84a563",
+        "size_in_bytes": 31635
+      },
+      {
+        "_path": "Lib/distutils/command/build_py.py",
+        "path_type": "hardlink",
+        "sha256": "4bf365c3885913c3e7220a97e4e14c766b7e19298e84f410e1fda3af5b819e85",
+        "sha256_in_prefix": "4bf365c3885913c3e7220a97e4e14c766b7e19298e84f410e1fda3af5b819e85",
+        "size_in_bytes": 17190
+      },
+      {
+        "_path": "Lib/distutils/command/build_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "68ac9c2493f1dcb7d9d5cbd981225ac670f62e7bd1339589fbcc64a5d81c2ec2",
+        "sha256_in_prefix": "68ac9c2493f1dcb7d9d5cbd981225ac670f62e7bd1339589fbcc64a5d81c2ec2",
+        "size_in_bytes": 6232
+      },
+      {
+        "_path": "Lib/distutils/command/check.py",
+        "path_type": "hardlink",
+        "sha256": "9927e429a3a9e968e41ae0bd5fa5ce2d691dfc1aa5e84b532b8089a8d3e87c0f",
+        "sha256_in_prefix": "9927e429a3a9e968e41ae0bd5fa5ce2d691dfc1aa5e84b532b8089a8d3e87c0f",
+        "size_in_bytes": 5636
+      },
+      {
+        "_path": "Lib/distutils/command/clean.py",
+        "path_type": "hardlink",
+        "sha256": "d930ade3baeee2165933445f55f5188f96dba6272918b3f8421c398c1b6fa7d9",
+        "sha256_in_prefix": "d930ade3baeee2165933445f55f5188f96dba6272918b3f8421c398c1b6fa7d9",
+        "size_in_bytes": 2776
+      },
+      {
+        "_path": "Lib/distutils/command/command_template",
+        "path_type": "hardlink",
+        "sha256": "7c1c707cd6ad3872515cf3fc9d8dd1a3f7cc08e3eb71813ed427499b256a8751",
+        "sha256_in_prefix": "7c1c707cd6ad3872515cf3fc9d8dd1a3f7cc08e3eb71813ed427499b256a8751",
+        "size_in_bytes": 633
+      },
+      {
+        "_path": "Lib/distutils/command/config.py",
+        "path_type": "hardlink",
+        "sha256": "d9a4e3c30dcfc23301f3e6626c27b83fb07ea86d61335827feb257632c51cfa7",
+        "sha256_in_prefix": "d9a4e3c30dcfc23301f3e6626c27b83fb07ea86d61335827feb257632c51cfa7",
+        "size_in_bytes": 13117
+      },
+      {
+        "_path": "Lib/distutils/command/install.py",
+        "path_type": "hardlink",
+        "sha256": "5f24c6efed482c0f0875a58693f57fa95b3ebf614bfa7c99e35bd46ec31db757",
+        "sha256_in_prefix": "5f24c6efed482c0f0875a58693f57fa95b3ebf614bfa7c99e35bd46ec31db757",
+        "size_in_bytes": 26805
+      },
+      {
+        "_path": "Lib/distutils/command/install_data.py",
+        "path_type": "hardlink",
+        "sha256": "62118e0308778093ea17b7a6e57034ae6a51e36cf56cb87cd28a049730f252f9",
+        "sha256_in_prefix": "62118e0308778093ea17b7a6e57034ae6a51e36cf56cb87cd28a049730f252f9",
+        "size_in_bytes": 2822
+      },
+      {
+        "_path": "Lib/distutils/command/install_egg_info.py",
+        "path_type": "hardlink",
+        "sha256": "d245b496254c79a7648d7d197117cca6d2857a7d3b1b0ea0cb0d551d3e4a2307",
+        "sha256_in_prefix": "d245b496254c79a7648d7d197117cca6d2857a7d3b1b0ea0cb0d551d3e4a2307",
+        "size_in_bytes": 2603
+      },
+      {
+        "_path": "Lib/distutils/command/install_headers.py",
+        "path_type": "hardlink",
+        "sha256": "5d0ea27646c80dfaf59635c23b39ee55432f385a47067e9c2b45b3f6020cd9be",
+        "sha256_in_prefix": "5d0ea27646c80dfaf59635c23b39ee55432f385a47067e9c2b45b3f6020cd9be",
+        "size_in_bytes": 1298
+      },
+      {
+        "_path": "Lib/distutils/command/install_lib.py",
+        "path_type": "hardlink",
+        "sha256": "f40a1f47e30ef6502d8f0c2eba40a9b5ea4e68910a3195b65478b2479854ec70",
+        "sha256_in_prefix": "f40a1f47e30ef6502d8f0c2eba40a9b5ea4e68910a3195b65478b2479854ec70",
+        "size_in_bytes": 8397
+      },
+      {
+        "_path": "Lib/distutils/command/install_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "fc22d4790c06251718da48a4edaccf327e4876d0c2ae359d52f675921946e9c9",
+        "sha256_in_prefix": "fc22d4790c06251718da48a4edaccf327e4876d0c2ae359d52f675921946e9c9",
+        "size_in_bytes": 2017
+      },
+      {
+        "_path": "Lib/distutils/command/register.py",
+        "path_type": "hardlink",
+        "sha256": "da36aaf7debcaedda9b91543071d476cd897bf6eee3a4f22744ff894f7ffdd53",
+        "sha256_in_prefix": "da36aaf7debcaedda9b91543071d476cd897bf6eee3a4f22744ff894f7ffdd53",
+        "size_in_bytes": 11712
+      },
+      {
+        "_path": "Lib/distutils/command/sdist.py",
+        "path_type": "hardlink",
+        "sha256": "aa8b498c03b3ca1263ab6fa80c89a3345aceb5a4a778414325307eb04935c275",
+        "sha256_in_prefix": "aa8b498c03b3ca1263ab6fa80c89a3345aceb5a4a778414325307eb04935c275",
+        "size_in_bytes": 19005
+      },
+      {
+        "_path": "Lib/distutils/command/upload.py",
+        "path_type": "hardlink",
+        "sha256": "ed9475fb90f3ef73d98f8f1f40b8637de2767c9c4fca95975b0a2c55164e5b8c",
+        "sha256_in_prefix": "ed9475fb90f3ef73d98f8f1f40b8637de2767c9c4fca95975b0a2c55164e5b8c",
+        "size_in_bytes": 7621
+      },
+      {
+        "_path": "Lib/distutils/command/wininst-10.0-amd64.exe",
+        "path_type": "hardlink",
+        "sha256": "b2e32b3fa44b3a9a8fdfa906627355f6f48b4821929f9bce5ded2d07894361d4",
+        "sha256_in_prefix": "b2e32b3fa44b3a9a8fdfa906627355f6f48b4821929f9bce5ded2d07894361d4",
+        "size_in_bytes": 222208
+      },
+      {
+        "_path": "Lib/distutils/command/wininst-10.0.exe",
+        "path_type": "hardlink",
+        "sha256": "1aa3927c7985386d42759656665c7b422ee226df16a19446af6d9a6613b8ae9b",
+        "sha256_in_prefix": "1aa3927c7985386d42759656665c7b422ee226df16a19446af6d9a6613b8ae9b",
+        "size_in_bytes": 190976
+      },
+      {
+        "_path": "Lib/distutils/command/wininst-14.0-amd64.exe",
+        "path_type": "hardlink",
+        "sha256": "0cf9864ae3a8679ed503f954a453452c93fa44f99ca6f39bbc5860abde7fd35e",
+        "sha256_in_prefix": "0cf9864ae3a8679ed503f954a453452c93fa44f99ca6f39bbc5860abde7fd35e",
+        "size_in_bytes": 587776
+      },
+      {
+        "_path": "Lib/distutils/command/wininst-14.0.exe",
+        "path_type": "hardlink",
+        "sha256": "cd8e84c1f8d1ee3a7014343e3fb236329d2b67c1ec233ea4b208d99e3f95105b",
+        "sha256_in_prefix": "cd8e84c1f8d1ee3a7014343e3fb236329d2b67c1ec233ea4b208d99e3f95105b",
+        "size_in_bytes": 458240
+      },
+      {
+        "_path": "Lib/distutils/command/wininst-6.0.exe",
+        "path_type": "hardlink",
+        "sha256": "751941b4e09898c31791efeb5f90fc7367c89831d4a98637ed505e40763e287b",
+        "sha256_in_prefix": "751941b4e09898c31791efeb5f90fc7367c89831d4a98637ed505e40763e287b",
+        "size_in_bytes": 61440
+      },
+      {
+        "_path": "Lib/distutils/command/wininst-7.1.exe",
+        "path_type": "hardlink",
+        "sha256": "4a3387a54eeca83f3a8ff1f5f282f7966c9e7bfe159c8eb45444cab01b3e167e",
+        "sha256_in_prefix": "4a3387a54eeca83f3a8ff1f5f282f7966c9e7bfe159c8eb45444cab01b3e167e",
+        "size_in_bytes": 65536
+      },
+      {
+        "_path": "Lib/distutils/command/wininst-8.0.exe",
+        "path_type": "hardlink",
+        "sha256": "e362670f93cdd952335b1a41e5529f184f2022ea4d41817a9781b150b062511c",
+        "sha256_in_prefix": "e362670f93cdd952335b1a41e5529f184f2022ea4d41817a9781b150b062511c",
+        "size_in_bytes": 61440
+      },
+      {
+        "_path": "Lib/distutils/command/wininst-9.0-amd64.exe",
+        "path_type": "hardlink",
+        "sha256": "84fe7824717bb55d7f32c7487e37012a1bc6cd4c8c0202be4bfb07e770f8dc51",
+        "sha256_in_prefix": "84fe7824717bb55d7f32c7487e37012a1bc6cd4c8c0202be4bfb07e770f8dc51",
+        "size_in_bytes": 224256
+      },
+      {
+        "_path": "Lib/distutils/command/wininst-9.0.exe",
+        "path_type": "hardlink",
+        "sha256": "13b98844b2fa4a39a4d8ebb414fc79450d5ab4f0c8f5141ac06d40b2a0431ea4",
+        "sha256_in_prefix": "13b98844b2fa4a39a4d8ebb414fc79450d5ab4f0c8f5141ac06d40b2a0431ea4",
+        "size_in_bytes": 196096
+      },
+      {
+        "_path": "Lib/distutils/config.py",
+        "path_type": "hardlink",
+        "sha256": "76d1e06e5c7d2617f2acac75f89ec9971c3f7fbb3c65b3c54228b65163136696",
+        "sha256_in_prefix": "76d1e06e5c7d2617f2acac75f89ec9971c3f7fbb3c65b3c54228b65163136696",
+        "size_in_bytes": 4827
+      },
+      {
+        "_path": "Lib/distutils/core.py",
+        "path_type": "hardlink",
+        "sha256": "8db74e92938ad3dc62fb9eaf861c2f9f77d87612dbe4324ef2adcad5f9d0cf44",
+        "sha256_in_prefix": "8db74e92938ad3dc62fb9eaf861c2f9f77d87612dbe4324ef2adcad5f9d0cf44",
+        "size_in_bytes": 8876
+      },
+      {
+        "_path": "Lib/distutils/cygwinccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "3b7116ed0f55abfe45f4378c25388bd086a382e6bbf0b4cf89b8547988504211",
+        "sha256_in_prefix": "3b7116ed0f55abfe45f4378c25388bd086a382e6bbf0b4cf89b8547988504211",
+        "size_in_bytes": 16618
+      },
+      {
+        "_path": "Lib/distutils/debug.py",
+        "path_type": "hardlink",
+        "sha256": "37a32b4c0a8aea5f52564ead5b0791d74f0f33c3a5eea3657f257e9c770b86c6",
+        "sha256_in_prefix": "37a32b4c0a8aea5f52564ead5b0791d74f0f33c3a5eea3657f257e9c770b86c6",
+        "size_in_bytes": 139
+      },
+      {
+        "_path": "Lib/distutils/dep_util.py",
+        "path_type": "hardlink",
+        "sha256": "1ae47d230fe3cd9464c9e989e475fcac1ff0446c642017019b5aa1e78afbce19",
+        "sha256_in_prefix": "1ae47d230fe3cd9464c9e989e475fcac1ff0446c642017019b5aa1e78afbce19",
+        "size_in_bytes": 3491
+      },
+      {
+        "_path": "Lib/distutils/dir_util.py",
+        "path_type": "hardlink",
+        "sha256": "5308413944dc57ae464f071ee123ee4d747c67cab72d811c9adb6a7066f46d8a",
+        "sha256_in_prefix": "5308413944dc57ae464f071ee123ee4d747c67cab72d811c9adb6a7066f46d8a",
+        "size_in_bytes": 7778
+      },
+      {
+        "_path": "Lib/distutils/dist.py",
+        "path_type": "hardlink",
+        "sha256": "1e797f81633e34c7993030ac4047b0cd43e49739d40dd03ef262d5c7dd7b17d2",
+        "sha256_in_prefix": "1e797f81633e34c7993030ac4047b0cd43e49739d40dd03ef262d5c7dd7b17d2",
+        "size_in_bytes": 50385
+      },
+      {
+        "_path": "Lib/distutils/errors.py",
+        "path_type": "hardlink",
+        "sha256": "62bead29919dcc1a0d8b9def06d8aad1427ffd7d390a6c5275026a3966b0e926",
+        "sha256_in_prefix": "62bead29919dcc1a0d8b9def06d8aad1427ffd7d390a6c5275026a3966b0e926",
+        "size_in_bytes": 3577
+      },
+      {
+        "_path": "Lib/distutils/extension.py",
+        "path_type": "hardlink",
+        "sha256": "6d36f74340a87af18a62fe5d5f596cfbe2e7f2d941d3e5043ac8bd070ce567eb",
+        "sha256_in_prefix": "6d36f74340a87af18a62fe5d5f596cfbe2e7f2d941d3e5043ac8bd070ce567eb",
+        "size_in_bytes": 10515
+      },
+      {
+        "_path": "Lib/distutils/fancy_getopt.py",
+        "path_type": "hardlink",
+        "sha256": "38fc69d82c478b5629fddd43f09c56e147aaf5f0bbd6d7a040569a7e1e7c1865",
+        "sha256_in_prefix": "38fc69d82c478b5629fddd43f09c56e147aaf5f0bbd6d7a040569a7e1e7c1865",
+        "size_in_bytes": 17784
+      },
+      {
+        "_path": "Lib/distutils/file_util.py",
+        "path_type": "hardlink",
+        "sha256": "d2152a7c8b4dff1d83562851d0c1dd03828231508e3bc568072685a7f6ba3038",
+        "sha256_in_prefix": "d2152a7c8b4dff1d83562851d0c1dd03828231508e3bc568072685a7f6ba3038",
+        "size_in_bytes": 8148
+      },
+      {
+        "_path": "Lib/distutils/filelist.py",
+        "path_type": "hardlink",
+        "sha256": "f1b471873a7616c6a81d3ed3b8a0f842372e87f07d3b0ff14edfe1b5926f3764",
+        "sha256_in_prefix": "f1b471873a7616c6a81d3ed3b8a0f842372e87f07d3b0ff14edfe1b5926f3764",
+        "size_in_bytes": 12832
+      },
+      {
+        "_path": "Lib/distutils/log.py",
+        "path_type": "hardlink",
+        "sha256": "8560667540b62bddbb41c56fdd110c5b71cc3dc97171c3d09e0c4b4ae517425d",
+        "sha256_in_prefix": "8560667540b62bddbb41c56fdd110c5b71cc3dc97171c3d09e0c4b4ae517425d",
+        "size_in_bytes": 1969
+      },
+      {
+        "_path": "Lib/distutils/msvc9compiler.py",
+        "path_type": "hardlink",
+        "sha256": "33d3edc009158d1bf1353165440929e8403935776c16bfaa775f97466f8a8ac3",
+        "sha256_in_prefix": "33d3edc009158d1bf1353165440929e8403935776c16bfaa775f97466f8a8ac3",
+        "size_in_bytes": 30453
+      },
+      {
+        "_path": "Lib/distutils/msvccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "658b27520202e2d653d969096d39135325520807369c533d0d5288b887cf054d",
+        "sha256_in_prefix": "658b27520202e2d653d969096d39135325520807369c533d0d5288b887cf054d",
+        "size_in_bytes": 23540
+      },
+      {
+        "_path": "Lib/distutils/spawn.py",
+        "path_type": "hardlink",
+        "sha256": "87336cdb85c2f6ecf2c67cd8a43903bf2cf884c218b1661dcc63a52ad96343e7",
+        "sha256_in_prefix": "87336cdb85c2f6ecf2c67cd8a43903bf2cf884c218b1661dcc63a52ad96343e7",
+        "size_in_bytes": 4660
+      },
+      {
+        "_path": "Lib/distutils/sysconfig.py",
+        "path_type": "hardlink",
+        "sha256": "6b9be3e90db371ce68184810d50348e5beeb7a19dfaa2fff7aba817f8a263c69",
+        "sha256_in_prefix": "6b9be3e90db371ce68184810d50348e5beeb7a19dfaa2fff7aba817f8a263c69",
+        "size_in_bytes": 20855
+      },
+      {
+        "_path": "Lib/distutils/tests/Setup.sample",
+        "path_type": "hardlink",
+        "sha256": "ff839230cf999711c05b9ee030a7e843376aa51190971fd597643508cea7dc74",
+        "sha256_in_prefix": "ff839230cf999711c05b9ee030a7e843376aa51190971fd597643508cea7dc74",
+        "size_in_bytes": 2249
+      },
+      {
+        "_path": "Lib/distutils/tests/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "0f82d124d2bb2076ae5364284dffec71745ac85518a8b9480338bec642b40ff5",
+        "sha256_in_prefix": "0f82d124d2bb2076ae5364284dffec71745ac85518a8b9480338bec642b40ff5",
+        "size_in_bytes": 1344
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d46fec41d6db4e1d8b6d997e03d07627d64d977b47a67370cd804298df9ea1e2",
+        "sha256_in_prefix": "d46fec41d6db4e1d8b6d997e03d07627d64d977b47a67370cd804298df9ea1e2",
+        "size_in_bytes": 1328
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/support.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "37bb1379dca6406bda8812df0134bf71175f17d1ffe49061bd3b034df91b8472",
+        "sha256_in_prefix": "37bb1379dca6406bda8812df0134bf71175f17d1ffe49061bd3b034df91b8472",
+        "size_in_bytes": 7406
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_archive_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4d20bb742ddbaf2452d06cd68e76711dda7982e8efd71dd0dc44a363482a1ef7",
+        "sha256_in_prefix": "4d20bb742ddbaf2452d06cd68e76711dda7982e8efd71dd0dc44a363482a1ef7",
+        "size_in_bytes": 11902
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_bdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6b33adbd15c860f27d2fc298df18441746bd9bfa1d9d08340bee6131c8cd3469",
+        "sha256_in_prefix": "6b33adbd15c860f27d2fc298df18441746bd9bfa1d9d08340bee6131c8cd3469",
+        "size_in_bytes": 1830
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_bdist_dumb.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8b8bc4d99cc8a4761e67b70d447f2591dd40f1c1911e8b67e4c9080ee2be9a16",
+        "sha256_in_prefix": "8b8bc4d99cc8a4761e67b70d447f2591dd40f1c1911e8b67e4c9080ee2be9a16",
+        "size_in_bytes": 2839
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_bdist_msi.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "da133c045a2aa91fe9f78f99ee44fe074be1f4e7e9ea20d9ccd377686ab8bbe6",
+        "sha256_in_prefix": "da133c045a2aa91fe9f78f99ee44fe074be1f4e7e9ea20d9ccd377686ab8bbe6",
+        "size_in_bytes": 1169
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_bdist_rpm.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "94ceebe15a6c1fb04218471a360e04ca114dfc534b7057e103db4f9da22f6907",
+        "sha256_in_prefix": "94ceebe15a6c1fb04218471a360e04ca114dfc534b7057e103db4f9da22f6907",
+        "size_in_bytes": 3605
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_bdist_wininst.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bac37b9582910b568ecde98fbadaa90d514b2f2897ad5bca9b624b2d5870e652",
+        "sha256_in_prefix": "bac37b9582910b568ecde98fbadaa90d514b2f2897ad5bca9b624b2d5870e652",
+        "size_in_bytes": 1381
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_build.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7d3b313c955e90b9e8abcec2ce83a6c5d1067de98ff7a30d66da45ed66a20300",
+        "sha256_in_prefix": "7d3b313c955e90b9e8abcec2ce83a6c5d1067de98ff7a30d66da45ed66a20300",
+        "size_in_bytes": 1623
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_build_clib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2f9d3d391487eee2a68ef7b881d8436daae2f88b288951a0f2f074797e88525e",
+        "sha256_in_prefix": "2f9d3d391487eee2a68ef7b881d8436daae2f88b288951a0f2f074797e88525e",
+        "size_in_bytes": 3685
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_build_ext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "46f288b19c12eb7ff9ab5ada042b67e1031381b76b55a7ef788d981203e1877f",
+        "sha256_in_prefix": "46f288b19c12eb7ff9ab5ada042b67e1031381b76b55a7ef788d981203e1877f",
+        "size_in_bytes": 13546
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_build_py.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "89af27549a8b13ae6e89c30e57c209051582d5bfb079001471e036fa5830410d",
+        "sha256_in_prefix": "89af27549a8b13ae6e89c30e57c209051582d5bfb079001471e036fa5830410d",
+        "size_in_bytes": 4999
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_build_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b568e31c28c1614df3dd5c8a3c189c49531e162ffcb8b7ec0c3fa35c3533ab13",
+        "sha256_in_prefix": "b568e31c28c1614df3dd5c8a3c189c49531e162ffcb8b7ec0c3fa35c3533ab13",
+        "size_in_bytes": 3470
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_check.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b566cd82a0f1e2fc9b702e6eeb739a86c32eb4bc23cfb375dd8985d92249926f",
+        "sha256_in_prefix": "b566cd82a0f1e2fc9b702e6eeb739a86c32eb4bc23cfb375dd8985d92249926f",
+        "size_in_bytes": 4165
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_clean.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e50ae441555d7bd0b526b90246a0da12550624d98c733ab9aa52c576621fb9c7",
+        "sha256_in_prefix": "e50ae441555d7bd0b526b90246a0da12550624d98c733ab9aa52c576621fb9c7",
+        "size_in_bytes": 1561
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_cmd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d399e2187a5cfe8399e79b197b14b1fce1561c2845b4b1127761401c72ed56cb",
+        "sha256_in_prefix": "d399e2187a5cfe8399e79b197b14b1fce1561c2845b4b1127761401c72ed56cb",
+        "size_in_bytes": 4292
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_config.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ae696bba0b392891910cdbc1aab55fc343045b466bdd9783b0968269cdf6ead6",
+        "sha256_in_prefix": "ae696bba0b392891910cdbc1aab55fc343045b466bdd9783b0968269cdf6ead6",
+        "size_in_bytes": 4090
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_config_cmd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5f914ed36273e3a75e06d494fee420b57f1eae37ce6b4995b8e3b8590b004769",
+        "sha256_in_prefix": "5f914ed36273e3a75e06d494fee420b57f1eae37ce6b4995b8e3b8590b004769",
+        "size_in_bytes": 3430
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_core.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "238a29f51c83d99460e27e6e85b4ae8c8422089417eb1f6e453303e0f6eeab10",
+        "sha256_in_prefix": "238a29f51c83d99460e27e6e85b4ae8c8422089417eb1f6e453303e0f6eeab10",
+        "size_in_bytes": 4186
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_cygwinccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7e9461a4d23cc208efbe01b12684fc323c359d0e1e27a11ee40a1cda1b3b2828",
+        "sha256_in_prefix": "7e9461a4d23cc208efbe01b12684fc323c359d0e1e27a11ee40a1cda1b3b2828",
+        "size_in_bytes": 4457
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_dep_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b518d13f5159e44cdd801b0e2439ab7119588597641af3d70b7d1c43b0c41697",
+        "sha256_in_prefix": "b518d13f5159e44cdd801b0e2439ab7119588597641af3d70b7d1c43b0c41697",
+        "size_in_bytes": 2270
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_dir_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b2fcf4c7885ecd8a121e051728bec88a6028d783e91865a49cd779e4db527cd6",
+        "sha256_in_prefix": "b2fcf4c7885ecd8a121e051728bec88a6028d783e91865a49cd779e4db527cd6",
+        "size_in_bytes": 4864
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_dist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0c967c827c9fc6100658fba4ff58d7c7e3eb01764afa7fdd59ed53c128d94e05",
+        "sha256_in_prefix": "0c967c827c9fc6100658fba4ff58d7c7e3eb01764afa7fdd59ed53c128d94e05",
+        "size_in_bytes": 16389
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_extension.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3f7ecccdd5d5294f662d0cb2fb0dcc83d8c9105bf778a6d6826e4f1ad9dc7097",
+        "sha256_in_prefix": "3f7ecccdd5d5294f662d0cb2fb0dcc83d8c9105bf778a6d6826e4f1ad9dc7097",
+        "size_in_bytes": 2401
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_file_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "80f3a4fac489a182c16cb9219a50ba79cd7dcece8df119b7b1e0bd1139e826d8",
+        "sha256_in_prefix": "80f3a4fac489a182c16cb9219a50ba79cd7dcece8df119b7b1e0bd1139e826d8",
+        "size_in_bytes": 4552
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_filelist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "abe487fab88822b8513b35478e9d7298d9d51eb730c91dc2b2f848ec97f06be6",
+        "sha256_in_prefix": "abe487fab88822b8513b35478e9d7298d9d51eb730c91dc2b2f848ec97f06be6",
+        "size_in_bytes": 8403
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "53495ab5edd234f1749fb4556214c8a801335b22e05476815f76fccff176958b",
+        "sha256_in_prefix": "53495ab5edd234f1749fb4556214c8a801335b22e05476815f76fccff176958b",
+        "size_in_bytes": 7100
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_install_data.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "92d390a08590068f3069dd7a2c04c57585032c80805189836df5d03ce216f3ea",
+        "sha256_in_prefix": "92d390a08590068f3069dd7a2c04c57585032c80805189836df5d03ce216f3ea",
+        "size_in_bytes": 1929
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_install_headers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "25a58b22cd19381949a059d6e74a6ee1c09ef7a339df58868cdf815752309746",
+        "sha256_in_prefix": "25a58b22cd19381949a059d6e74a6ee1c09ef7a339df58868cdf815752309746",
+        "size_in_bytes": 1360
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_install_lib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e4fc4895dd777ad10b7a72deaf36e5c1f6e564ab66f2e31b72712168fce09e07",
+        "sha256_in_prefix": "e4fc4895dd777ad10b7a72deaf36e5c1f6e564ab66f2e31b72712168fce09e07",
+        "size_in_bytes": 3471
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_install_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6bf6902e564954cab3567fa617cfca9bbe35b9c4fc3de65c3bb9484b3062cfdd",
+        "sha256_in_prefix": "6bf6902e564954cab3567fa617cfca9bbe35b9c4fc3de65c3bb9484b3062cfdd",
+        "size_in_bytes": 2430
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_log.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "085005e224574a6df9114b83bc6414775258303a9f47d53da2b98e2381b08dcc",
+        "sha256_in_prefix": "085005e224574a6df9114b83bc6414775258303a9f47d53da2b98e2381b08dcc",
+        "size_in_bytes": 1632
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_msvc9compiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8ed1316352fc18767375ec65296fd656dd1374a075cd6793aeedd2700620f129",
+        "sha256_in_prefix": "8ed1316352fc18767375ec65296fd656dd1374a075cd6793aeedd2700620f129",
+        "size_in_bytes": 5647
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_msvccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "02dfcce9dff7905df5e148116b59172d16eb53a6514b4a306f43ed8f64b04103",
+        "sha256_in_prefix": "02dfcce9dff7905df5e148116b59172d16eb53a6514b4a306f43ed8f64b04103",
+        "size_in_bytes": 2617
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_register.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "98d70dbcc6c94bb3337f29ece321cd8a1f67203a74c5aa5e50aa46e8fb44c00c",
+        "sha256_in_prefix": "98d70dbcc6c94bb3337f29ece321cd8a1f67203a74c5aa5e50aa46e8fb44c00c",
+        "size_in_bytes": 8125
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_sdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2b1dc13ed04a774eab04b35c2af297c17562c3d326822f027157038268a4a276",
+        "sha256_in_prefix": "2b1dc13ed04a774eab04b35c2af297c17562c3d326822f027157038268a4a276",
+        "size_in_bytes": 12863
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_spawn.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "df066ef664605f5294e8aa56572378176c1e46caf6d90c1ef6a50e7a0be0379a",
+        "sha256_in_prefix": "df066ef664605f5294e8aa56572378176c1e46caf6d90c1ef6a50e7a0be0379a",
+        "size_in_bytes": 3565
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_sysconfig.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "275212a20c93d152cffa590fb327a4cf03b867a9cba48e5062ab353650522cc7",
+        "sha256_in_prefix": "275212a20c93d152cffa590fb327a4cf03b867a9cba48e5062ab353650522cc7",
+        "size_in_bytes": 8829
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_text_file.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "09daac6c489ffdb0506a2f336d5cdc3080fbed2a4303805daf2033a9347174f6",
+        "sha256_in_prefix": "09daac6c489ffdb0506a2f336d5cdc3080fbed2a4303805daf2033a9347174f6",
+        "size_in_bytes": 2373
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_unixccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4a1d5b79033ee482706f9c3f7ecda1b41ee4adb26723dceb947439cd76220e05",
+        "sha256_in_prefix": "4a1d5b79033ee482706f9c3f7ecda1b41ee4adb26723dceb947439cd76220e05",
+        "size_in_bytes": 4528
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_upload.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0bb9b5d3da6d915101dc67f4bd256d97ae7c4355eb4433409307e577076a6ea9",
+        "sha256_in_prefix": "0bb9b5d3da6d915101dc67f4bd256d97ae7c4355eb4433409307e577076a6ea9",
+        "size_in_bytes": 6809
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a3e0ac875708d0896dacf4617108633b0280400922f5d93a5c3628652745bf4c",
+        "sha256_in_prefix": "a3e0ac875708d0896dacf4617108633b0280400922f5d93a5c3628652745bf4c",
+        "size_in_bytes": 9039
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a81a0cd571616e18583f22344547bbee45f313f209b6a773535e484389a27ffc",
+        "sha256_in_prefix": "a81a0cd571616e18583f22344547bbee45f313f209b6a773535e484389a27ffc",
+        "size_in_bytes": 2422
+      },
+      {
+        "_path": "Lib/distutils/tests/__pycache__/test_versionpredicate.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4c86cbde687609e1e3b3843cd11c95a1ef2ea3a8c35dfcf07b7a7820a30fa55d",
+        "sha256_in_prefix": "4c86cbde687609e1e3b3843cd11c95a1ef2ea3a8c35dfcf07b7a7820a30fa55d",
+        "size_in_bytes": 510
+      },
+      {
+        "_path": "Lib/distutils/tests/includetest.rst",
+        "path_type": "hardlink",
+        "sha256": "1a766ccac6850b0424118733e2b086803921e0829f98ad0719be671a5da4263c",
+        "sha256_in_prefix": "1a766ccac6850b0424118733e2b086803921e0829f98ad0719be671a5da4263c",
+        "size_in_bytes": 25
+      },
+      {
+        "_path": "Lib/distutils/tests/support.py",
+        "path_type": "hardlink",
+        "sha256": "c334547061fc33e59fd008fcb4e16b2e78e17051e068f44f9f8a4b8ffdcf0cd0",
+        "sha256_in_prefix": "c334547061fc33e59fd008fcb4e16b2e78e17051e068f44f9f8a4b8ffdcf0cd0",
+        "size_in_bytes": 6478
+      },
+      {
+        "_path": "Lib/distutils/tests/test_archive_util.py",
+        "path_type": "hardlink",
+        "sha256": "2231f062f77245c1d62109a742f53d85d8b69d91687957e34e781c8d5f6b5fe5",
+        "sha256_in_prefix": "2231f062f77245c1d62109a742f53d85d8b69d91687957e34e781c8d5f6b5fe5",
+        "size_in_bytes": 14301
+      },
+      {
+        "_path": "Lib/distutils/tests/test_bdist.py",
+        "path_type": "hardlink",
+        "sha256": "1d519f5e94d0e278abb70294a6f9cc64fcb4d0681be838223c7a4b928b4a9075",
+        "sha256_in_prefix": "1d519f5e94d0e278abb70294a6f9cc64fcb4d0681be838223c7a4b928b4a9075",
+        "size_in_bytes": 1893
+      },
+      {
+        "_path": "Lib/distutils/tests/test_bdist_dumb.py",
+        "path_type": "hardlink",
+        "sha256": "fbe9884e5e1a28ff1d01c087bae2aff7fce7f80884f16b7e3941945e977f3ec2",
+        "sha256_in_prefix": "fbe9884e5e1a28ff1d01c087bae2aff7fce7f80884f16b7e3941945e977f3ec2",
+        "size_in_bytes": 2905
+      },
+      {
+        "_path": "Lib/distutils/tests/test_bdist_msi.py",
+        "path_type": "hardlink",
+        "sha256": "7ebce06c49098560f0ab5892bd0535fa277d3add18a0f3104d37e9f10a92d688",
+        "sha256_in_prefix": "7ebce06c49098560f0ab5892bd0535fa277d3add18a0f3104d37e9f10a92d688",
+        "size_in_bytes": 803
+      },
+      {
+        "_path": "Lib/distutils/tests/test_bdist_rpm.py",
+        "path_type": "hardlink",
+        "sha256": "e40ec9e60ee10385af078bf41b8a2fa126fc4f0919547e0a68f0b1aa2517f046",
+        "sha256_in_prefix": "e40ec9e60ee10385af078bf41b8a2fa126fc4f0919547e0a68f0b1aa2517f046",
+        "size_in_bytes": 5012
+      },
+      {
+        "_path": "Lib/distutils/tests/test_bdist_wininst.py",
+        "path_type": "hardlink",
+        "sha256": "ad00c7ab56f0db52811f208f3a366dfbc696711cb37015b2ef77dc0fbf00e592",
+        "sha256_in_prefix": "ad00c7ab56f0db52811f208f3a366dfbc696711cb37015b2ef77dc0fbf00e592",
+        "size_in_bytes": 1390
+      },
+      {
+        "_path": "Lib/distutils/tests/test_build.py",
+        "path_type": "hardlink",
+        "sha256": "c21e2ce5937429a9aeb92686b192e4751eb28399dd7af44bf524b5706c2237e8",
+        "sha256_in_prefix": "c21e2ce5937429a9aeb92686b192e4751eb28399dd7af44bf524b5706c2237e8",
+        "size_in_bytes": 1965
+      },
+      {
+        "_path": "Lib/distutils/tests/test_build_clib.py",
+        "path_type": "hardlink",
+        "sha256": "b9d25247d95a437a0729ea6a963877503dd83975d73fa4a0088bc3fe7f5faeda",
+        "sha256_in_prefix": "b9d25247d95a437a0729ea6a963877503dd83975d73fa4a0088bc3fe7f5faeda",
+        "size_in_bytes": 4631
+      },
+      {
+        "_path": "Lib/distutils/tests/test_build_ext.py",
+        "path_type": "hardlink",
+        "sha256": "12fe0131ff8dba636c727b1b0370d60a9817b50dcf3b9c726a64169e9745c912",
+        "sha256_in_prefix": "12fe0131ff8dba636c727b1b0370d60a9817b50dcf3b9c726a64169e9745c912",
+        "size_in_bytes": 20633
+      },
+      {
+        "_path": "Lib/distutils/tests/test_build_py.py",
+        "path_type": "hardlink",
+        "sha256": "1eeea30b412c1f9375c86965528f0fcea92cb59a9f6f7f827ad639f6d50d5432",
+        "sha256_in_prefix": "1eeea30b412c1f9375c86965528f0fcea92cb59a9f6f7f827ad639f6d50d5432",
+        "size_in_bytes": 6335
+      },
+      {
+        "_path": "Lib/distutils/tests/test_build_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "046407fe31a1b3416acbd34df0c4622c7f7e6fecf9859bcebd4214b6b62c505f",
+        "sha256_in_prefix": "046407fe31a1b3416acbd34df0c4622c7f7e6fecf9859bcebd4214b6b62c505f",
+        "size_in_bytes": 3593
+      },
+      {
+        "_path": "Lib/distutils/tests/test_check.py",
+        "path_type": "hardlink",
+        "sha256": "03950ad7681549157802d8c38005c59ed3c5df5d9f328636701bf24c9953984f",
+        "sha256_in_prefix": "03950ad7681549157802d8c38005c59ed3c5df5d9f328636701bf24c9953984f",
+        "size_in_bytes": 5711
+      },
+      {
+        "_path": "Lib/distutils/tests/test_clean.py",
+        "path_type": "hardlink",
+        "sha256": "af860768e940633cd0dda9bdb10d3faa9f018e4e94bcb29975cbfa8fcb7fe424",
+        "sha256_in_prefix": "af860768e940633cd0dda9bdb10d3faa9f018e4e94bcb29975cbfa8fcb7fe424",
+        "size_in_bytes": 1441
+      },
+      {
+        "_path": "Lib/distutils/tests/test_cmd.py",
+        "path_type": "hardlink",
+        "sha256": "f0e86363c03e17fcf28d44938d2d064d3de8419705acfa6f6f7a286a66e4b7ba",
+        "sha256_in_prefix": "f0e86363c03e17fcf28d44938d2d064d3de8419705acfa6f6f7a286a66e4b7ba",
+        "size_in_bytes": 3835
+      },
+      {
+        "_path": "Lib/distutils/tests/test_config.py",
+        "path_type": "hardlink",
+        "sha256": "1c0e82ceed789b3bd1c1de73d40a79c623b8698f07aad0299921bb4ab9f758ea",
+        "sha256_in_prefix": "1c0e82ceed789b3bd1c1de73d40a79c623b8698f07aad0299921bb4ab9f758ea",
+        "size_in_bytes": 3892
+      },
+      {
+        "_path": "Lib/distutils/tests/test_config_cmd.py",
+        "path_type": "hardlink",
+        "sha256": "ae2bcd54df6664081634a3e1f3998bedeab2c72ddcd46f3ad82ca5fe53980dcd",
+        "sha256_in_prefix": "ae2bcd54df6664081634a3e1f3998bedeab2c72ddcd46f3ad82ca5fe53980dcd",
+        "size_in_bytes": 3023
+      },
+      {
+        "_path": "Lib/distutils/tests/test_core.py",
+        "path_type": "hardlink",
+        "sha256": "5db584ee6c12f0b2284d79ab107e1a79a625f8b28d80bd6872031465e55bbfd6",
+        "sha256_in_prefix": "5db584ee6c12f0b2284d79ab107e1a79a625f8b28d80bd6872031465e55bbfd6",
+        "size_in_bytes": 4077
+      },
+      {
+        "_path": "Lib/distutils/tests/test_cygwinccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "ab94a3e3cc02359e455af7fed69ab8dc2266bf58a3b10d4153ace9a776b28fb6",
+        "sha256_in_prefix": "ab94a3e3cc02359e455af7fed69ab8dc2266bf58a3b10d4153ace9a776b28fb6",
+        "size_in_bytes": 5636
+      },
+      {
+        "_path": "Lib/distutils/tests/test_dep_util.py",
+        "path_type": "hardlink",
+        "sha256": "6dc13cad79303d04b81a83a9d556775a442e1369d45121a0e0ab8f13242328c1",
+        "sha256_in_prefix": "6dc13cad79303d04b81a83a9d556775a442e1369d45121a0e0ab8f13242328c1",
+        "size_in_bytes": 2820
+      },
+      {
+        "_path": "Lib/distutils/tests/test_dir_util.py",
+        "path_type": "hardlink",
+        "sha256": "44a92518311e69ba5e32529650673c6ac61b300b97800f8cd5423b429ca2abf1",
+        "sha256_in_prefix": "44a92518311e69ba5e32529650673c6ac61b300b97800f8cd5423b429ca2abf1",
+        "size_in_bytes": 4654
+      },
+      {
+        "_path": "Lib/distutils/tests/test_dist.py",
+        "path_type": "hardlink",
+        "sha256": "4748e879709eda31781ef3dae2da934387b47e971ec209a1ab5702e7874c801c",
+        "sha256_in_prefix": "4748e879709eda31781ef3dae2da934387b47e971ec209a1ab5702e7874c801c",
+        "size_in_bytes": 19080
+      },
+      {
+        "_path": "Lib/distutils/tests/test_extension.py",
+        "path_type": "hardlink",
+        "sha256": "e6dc27c1bc7eb5dcb6f3407587099018ab086866a88fcd0c71d13d415ebb1e50",
+        "sha256_in_prefix": "e6dc27c1bc7eb5dcb6f3407587099018ab086866a88fcd0c71d13d415ebb1e50",
+        "size_in_bytes": 2768
+      },
+      {
+        "_path": "Lib/distutils/tests/test_file_util.py",
+        "path_type": "hardlink",
+        "sha256": "2759b1ee544d0df40870f102dbc22ccf80e205ae2ff481cc13a8d0a3229677ba",
+        "sha256_in_prefix": "2759b1ee544d0df40870f102dbc22ccf80e205ae2ff481cc13a8d0a3229677ba",
+        "size_in_bytes": 4413
+      },
+      {
+        "_path": "Lib/distutils/tests/test_filelist.py",
+        "path_type": "hardlink",
+        "sha256": "c1f0dcc1e68ae2779395b1b88b99d551044fe2b149502d993fa0eefe6bf17bed",
+        "sha256_in_prefix": "c1f0dcc1e68ae2779395b1b88b99d551044fe2b149502d993fa0eefe6bf17bed",
+        "size_in_bytes": 11475
+      },
+      {
+        "_path": "Lib/distutils/tests/test_install.py",
+        "path_type": "hardlink",
+        "sha256": "5c1ccb61b8cda6982745ff2f6fd5b5973c468b53cd403dad06d9d47dfadd88ad",
+        "sha256_in_prefix": "5c1ccb61b8cda6982745ff2f6fd5b5973c468b53cd403dad06d9d47dfadd88ad",
+        "size_in_bytes": 8612
+      },
+      {
+        "_path": "Lib/distutils/tests/test_install_data.py",
+        "path_type": "hardlink",
+        "sha256": "e0a29d16cffd3997def9179353eb6ae020644c2e59a5d4dc5ec1583da51eab7e",
+        "sha256_in_prefix": "e0a29d16cffd3997def9179353eb6ae020644c2e59a5d4dc5ec1583da51eab7e",
+        "size_in_bytes": 2577
+      },
+      {
+        "_path": "Lib/distutils/tests/test_install_headers.py",
+        "path_type": "hardlink",
+        "sha256": "abbddc109ef35ed9aca855ca57629ff38f775f7a972da5771df9654e0bcdf8aa",
+        "sha256_in_prefix": "abbddc109ef35ed9aca855ca57629ff38f775f7a972da5771df9654e0bcdf8aa",
+        "size_in_bytes": 1238
+      },
+      {
+        "_path": "Lib/distutils/tests/test_install_lib.py",
+        "path_type": "hardlink",
+        "sha256": "b7bb725739e88f1529897190c26c969689735852da29b39f1fa962a7875dd531",
+        "sha256_in_prefix": "b7bb725739e88f1529897190c26c969689735852da29b39f1fa962a7875dd531",
+        "size_in_bytes": 3974
+      },
+      {
+        "_path": "Lib/distutils/tests/test_install_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "0a7e1d6f6befd7aa20f4acc0b9154f3206565a2ea5c81b71ad7b255d2b9195f8",
+        "sha256_in_prefix": "0a7e1d6f6befd7aa20f4acc0b9154f3206565a2ea5c81b71ad7b255d2b9195f8",
+        "size_in_bytes": 2625
+      },
+      {
+        "_path": "Lib/distutils/tests/test_log.py",
+        "path_type": "hardlink",
+        "sha256": "e79dada8f4e68c15b1ceb61f1f35354106972a6e3f29b69f351d701ad1ff3690",
+        "sha256_in_prefix": "e79dada8f4e68c15b1ceb61f1f35354106972a6e3f29b69f351d701ad1ff3690",
+        "size_in_bytes": 1864
+      },
+      {
+        "_path": "Lib/distutils/tests/test_msvc9compiler.py",
+        "path_type": "hardlink",
+        "sha256": "284acd052027b622bc696be5fd2068fb149cb82a10e6dd15537175604c1a212e",
+        "sha256_in_prefix": "284acd052027b622bc696be5fd2068fb149cb82a10e6dd15537175604c1a212e",
+        "size_in_bytes": 6038
+      },
+      {
+        "_path": "Lib/distutils/tests/test_msvccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "0d1dde41db44732b7bb09f00ecb0359d6c9434ddbe3065ea0ee3a93a9035543b",
+        "sha256_in_prefix": "0d1dde41db44732b7bb09f00ecb0359d6c9434ddbe3065ea0ee3a93a9035543b",
+        "size_in_bytes": 2845
+      },
+      {
+        "_path": "Lib/distutils/tests/test_register.py",
+        "path_type": "hardlink",
+        "sha256": "71dbb348e381137d9156ae36c93d16afc52347daa6caba50395350ed78af4020",
+        "sha256_in_prefix": "71dbb348e381137d9156ae36c93d16afc52347daa6caba50395350ed78af4020",
+        "size_in_bytes": 9765
+      },
+      {
+        "_path": "Lib/distutils/tests/test_sdist.py",
+        "path_type": "hardlink",
+        "sha256": "3821d243e910a11a7a4e9f2d2eff70820d5863bd5593de8d283b89e1fd8e0bea",
+        "sha256_in_prefix": "3821d243e910a11a7a4e9f2d2eff70820d5863bd5593de8d283b89e1fd8e0bea",
+        "size_in_bytes": 17047
+      },
+      {
+        "_path": "Lib/distutils/tests/test_spawn.py",
+        "path_type": "hardlink",
+        "sha256": "51ef043cded7c7261849ee3906e805d3e6c6b0afd2cd11399b73a7d965edcfd7",
+        "sha256_in_prefix": "51ef043cded7c7261849ee3906e805d3e6c6b0afd2cd11399b73a7d965edcfd7",
+        "size_in_bytes": 5460
+      },
+      {
+        "_path": "Lib/distutils/tests/test_sysconfig.py",
+        "path_type": "hardlink",
+        "sha256": "ead903245e111a5dd49874b796a229fd000f1e22997e79621aefd7e823757294",
+        "sha256_in_prefix": "ead903245e111a5dd49874b796a229fd000f1e22997e79621aefd7e823757294",
+        "size_in_bytes": 11045
+      },
+      {
+        "_path": "Lib/distutils/tests/test_text_file.py",
+        "path_type": "hardlink",
+        "sha256": "dbf3f1b388f55a2ac4c13336f2814fdc862ad52e88a93c7eca7cb3e68d2d8d9a",
+        "sha256_in_prefix": "dbf3f1b388f55a2ac4c13336f2814fdc862ad52e88a93c7eca7cb3e68d2d8d9a",
+        "size_in_bytes": 3436
+      },
+      {
+        "_path": "Lib/distutils/tests/test_unixccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "d1ba9f437337fa6fc2207074374ef50569f83ad49f3d7f7a5e38019710603b27",
+        "sha256_in_prefix": "d1ba9f437337fa6fc2207074374ef50569f83ad49f3d7f7a5e38019710603b27",
+        "size_in_bytes": 4629
+      },
+      {
+        "_path": "Lib/distutils/tests/test_upload.py",
+        "path_type": "hardlink",
+        "sha256": "5acabcbf6ad46d7c6cd0a3ab45796872944e8ddf21fa89c0cca6f1ecbb1cc733",
+        "sha256_in_prefix": "5acabcbf6ad46d7c6cd0a3ab45796872944e8ddf21fa89c0cca6f1ecbb1cc733",
+        "size_in_bytes": 7137
+      },
+      {
+        "_path": "Lib/distutils/tests/test_util.py",
+        "path_type": "hardlink",
+        "sha256": "69f109a6504cbe619342b664c938f97e39e253836a894be588688098bf9b8899",
+        "sha256_in_prefix": "69f109a6504cbe619342b664c938f97e39e253836a894be588688098bf9b8899",
+        "size_in_bytes": 11572
+      },
+      {
+        "_path": "Lib/distutils/tests/test_version.py",
+        "path_type": "hardlink",
+        "sha256": "9fad90df09845d5dd4b654f375c929f5532e2e243f77ab102aaeabf39a71e7e5",
+        "sha256_in_prefix": "9fad90df09845d5dd4b654f375c929f5532e2e243f77ab102aaeabf39a71e7e5",
+        "size_in_bytes": 3450
+      },
+      {
+        "_path": "Lib/distutils/tests/test_versionpredicate.py",
+        "path_type": "hardlink",
+        "sha256": "690003c23752f77c7ea1108cd51dd7e9b0ca7021ad925aa982bae5bcd2f988b0",
+        "sha256_in_prefix": "690003c23752f77c7ea1108cd51dd7e9b0ca7021ad925aa982bae5bcd2f988b0",
+        "size_in_bytes": 280
+      },
+      {
+        "_path": "Lib/distutils/text_file.py",
+        "path_type": "hardlink",
+        "sha256": "3ecb8025e59d289a0b495ffa37a229079fb43daf382b32d4b9c24c1516b3c372",
+        "sha256_in_prefix": "3ecb8025e59d289a0b495ffa37a229079fb43daf382b32d4b9c24c1516b3c372",
+        "size_in_bytes": 12483
+      },
+      {
+        "_path": "Lib/distutils/unixccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "24c46c478c003529742d7614f693c5532470aca9ed376f99ff6686b929acad27",
+        "sha256_in_prefix": "24c46c478c003529742d7614f693c5532470aca9ed376f99ff6686b929acad27",
+        "size_in_bytes": 15008
+      },
+      {
+        "_path": "Lib/distutils/util.py",
+        "path_type": "hardlink",
+        "sha256": "67e16da6f0a8d6cccd92cb08fa2b7eb96840df9f7de971dcb6d2d9894cdcd7f6",
+        "sha256_in_prefix": "67e16da6f0a8d6cccd92cb08fa2b7eb96840df9f7de971dcb6d2d9894cdcd7f6",
+        "size_in_bytes": 20913
+      },
+      {
+        "_path": "Lib/distutils/version.py",
+        "path_type": "hardlink",
+        "sha256": "f0da203fa34f3d0a69dc450c65c4fd73310789af9e86a3e8f2ca68fdeec08145",
+        "sha256_in_prefix": "f0da203fa34f3d0a69dc450c65c4fd73310789af9e86a3e8f2ca68fdeec08145",
+        "size_in_bytes": 12514
+      },
+      {
+        "_path": "Lib/distutils/versionpredicate.py",
+        "path_type": "hardlink",
+        "sha256": "671a4403e4d0bfcf2651673a85eb543b8a92a80dac6bb8a98d9dd010ae5ebc39",
+        "sha256_in_prefix": "671a4403e4d0bfcf2651673a85eb543b8a92a80dac6bb8a98d9dd010ae5ebc39",
+        "size_in_bytes": 5133
+      },
+      {
+        "_path": "Lib/doctest.py",
+        "path_type": "hardlink",
+        "sha256": "73c7a2d0005656e92f201d46b64bb48b7b20d91fd326574bc002db3df78747ee",
+        "sha256_in_prefix": "73c7a2d0005656e92f201d46b64bb48b7b20d91fd326574bc002db3df78747ee",
+        "size_in_bytes": 104568
+      },
+      {
+        "_path": "Lib/email/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "14eeb17ae40c6cc19b48a9bd5e2a0340ee3dd86a8d64bd1d5c4df8fcfa726c8a",
+        "sha256_in_prefix": "14eeb17ae40c6cc19b48a9bd5e2a0340ee3dd86a8d64bd1d5c4df8fcfa726c8a",
+        "size_in_bytes": 1766
+      },
+      {
+        "_path": "Lib/email/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0848ee3e479b147d965c26c546c3e05038cfe441e1099e20d79cea8f020a9818",
+        "sha256_in_prefix": "0848ee3e479b147d965c26c546c3e05038cfe441e1099e20d79cea8f020a9818",
+        "size_in_bytes": 1650
+      },
+      {
+        "_path": "Lib/email/__pycache__/_encoded_words.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ca5c605e6ded880d8450ac1f184e2b43ccd1d693cdcdd437215d7c7a21557d63",
+        "sha256_in_prefix": "ca5c605e6ded880d8450ac1f184e2b43ccd1d693cdcdd437215d7c7a21557d63",
+        "size_in_bytes": 5690
+      },
+      {
+        "_path": "Lib/email/__pycache__/_header_value_parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0c9262eb5755f3b338a4308b729f9840f1788d70a7d800b7f5f00f7efa2118b8",
+        "sha256_in_prefix": "0c9262eb5755f3b338a4308b729f9840f1788d70a7d800b7f5f00f7efa2118b8",
+        "size_in_bytes": 79847
+      },
+      {
+        "_path": "Lib/email/__pycache__/_parseaddr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a8e8c98883f71ab1151a27416cfea7c5edffd5e89012034b7d4460c31362dc7f",
+        "sha256_in_prefix": "a8e8c98883f71ab1151a27416cfea7c5edffd5e89012034b7d4460c31362dc7f",
+        "size_in_bytes": 12376
+      },
+      {
+        "_path": "Lib/email/__pycache__/_policybase.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "47f77ef07d3fcc61ea30db2954998cbdd2d9dddc5f1696b88c1ffff8e4a5f08c",
+        "sha256_in_prefix": "47f77ef07d3fcc61ea30db2954998cbdd2d9dddc5f1696b88c1ffff8e4a5f08c",
+        "size_in_bytes": 15249
+      },
+      {
+        "_path": "Lib/email/__pycache__/base64mime.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "351dfdf630c48a60c1de1d480a3351705c82984aec8ff6916a2fc6f7865f84b2",
+        "sha256_in_prefix": "351dfdf630c48a60c1de1d480a3351705c82984aec8ff6916a2fc6f7865f84b2",
+        "size_in_bytes": 3222
+      },
+      {
+        "_path": "Lib/email/__pycache__/charset.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "396261a208e49dfb57f77fd9e1be70f7e19731d1159b01ce173b459ed1f0a1a1",
+        "sha256_in_prefix": "396261a208e49dfb57f77fd9e1be70f7e19731d1159b01ce173b459ed1f0a1a1",
+        "size_in_bytes": 11436
+      },
+      {
+        "_path": "Lib/email/__pycache__/contentmanager.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "30ece3b035f733dd8975fc0f798c637ce4b8e5ddb692577710089b9383949a43",
+        "sha256_in_prefix": "30ece3b035f733dd8975fc0f798c637ce4b8e5ddb692577710089b9383949a43",
+        "size_in_bytes": 7343
+      },
+      {
+        "_path": "Lib/email/__pycache__/encoders.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d7e010369510cdd420737b7f0d54d94758964409b46854f53f2265f856333cc",
+        "sha256_in_prefix": "2d7e010369510cdd420737b7f0d54d94758964409b46854f53f2265f856333cc",
+        "size_in_bytes": 1605
+      },
+      {
+        "_path": "Lib/email/__pycache__/errors.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "df93543fb01856537a611a84ec19caa0f95abf5deaaa704e1dae17e758a58a70",
+        "sha256_in_prefix": "df93543fb01856537a611a84ec19caa0f95abf5deaaa704e1dae17e758a58a70",
+        "size_in_bytes": 6060
+      },
+      {
+        "_path": "Lib/email/__pycache__/feedparser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "888bc20e2aa8765754ce5b2be95a4c002782b03c4f5e570d2ca329e21cdbbdf2",
+        "sha256_in_prefix": "888bc20e2aa8765754ce5b2be95a4c002782b03c4f5e570d2ca329e21cdbbdf2",
+        "size_in_bytes": 10592
+      },
+      {
+        "_path": "Lib/email/__pycache__/generator.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "07220c1efeb7a35e485f35b9f10917601440940e2d9e96d64240ea3ed74caadf",
+        "sha256_in_prefix": "07220c1efeb7a35e485f35b9f10917601440940e2d9e96d64240ea3ed74caadf",
+        "size_in_bytes": 12963
+      },
+      {
+        "_path": "Lib/email/__pycache__/header.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5e08d6abe9dd7d0a979f0e730a7de8a18a5e7de8c449c5b1e217ba28752e3a53",
+        "sha256_in_prefix": "5e08d6abe9dd7d0a979f0e730a7de8a18a5e7de8c449c5b1e217ba28752e3a53",
+        "size_in_bytes": 16415
+      },
+      {
+        "_path": "Lib/email/__pycache__/headerregistry.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2198a8acbbdad81a702b183e8b950d46c92d194e4b8c6b96c227f96fe5c69381",
+        "sha256_in_prefix": "2198a8acbbdad81a702b183e8b950d46c92d194e4b8c6b96c227f96fe5c69381",
+        "size_in_bytes": 21949
+      },
+      {
+        "_path": "Lib/email/__pycache__/iterators.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "813f23309b62c1561ccfc96ae4e6eb405fd07c4c0577d79c8a3ec3b530b7a0ab",
+        "sha256_in_prefix": "813f23309b62c1561ccfc96ae4e6eb405fd07c4c0577d79c8a3ec3b530b7a0ab",
+        "size_in_bytes": 1914
+      },
+      {
+        "_path": "Lib/email/__pycache__/message.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1a7d88822d6f9f64c63c1bd7458e7e58f2c55e8a750bfc84caa086a3810e84ad",
+        "sha256_in_prefix": "1a7d88822d6f9f64c63c1bd7458e7e58f2c55e8a750bfc84caa086a3810e84ad",
+        "size_in_bytes": 37819
+      },
+      {
+        "_path": "Lib/email/__pycache__/parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3d5488fe974cc002aa6a7ef74a8feb8f7f32c4445334e09b625c1b17b0d7182d",
+        "sha256_in_prefix": "3d5488fe974cc002aa6a7ef74a8feb8f7f32c4445334e09b625c1b17b0d7182d",
+        "size_in_bytes": 5729
+      },
+      {
+        "_path": "Lib/email/__pycache__/policy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "35516abf0ae3ef4870dbebb55e9a503c60686eff932320d3cbdfca5b516287cc",
+        "sha256_in_prefix": "35516abf0ae3ef4870dbebb55e9a503c60686eff932320d3cbdfca5b516287cc",
+        "size_in_bytes": 9622
+      },
+      {
+        "_path": "Lib/email/__pycache__/quoprimime.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "86f31c6c2c4ee5690eae73160848c8a2d4372803cab9d25204ee402f3fa72812",
+        "sha256_in_prefix": "86f31c6c2c4ee5690eae73160848c8a2d4372803cab9d25204ee402f3fa72812",
+        "size_in_bytes": 7657
+      },
+      {
+        "_path": "Lib/email/__pycache__/utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "31a8dc4cb989e459f2b803afd38a85daed7ebddf36b4a768429a6c40d8500786",
+        "sha256_in_prefix": "31a8dc4cb989e459f2b803afd38a85daed7ebddf36b4a768429a6c40d8500786",
+        "size_in_bytes": 11734
+      },
+      {
+        "_path": "Lib/email/_encoded_words.py",
+        "path_type": "hardlink",
+        "sha256": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217",
+        "sha256_in_prefix": "4178321600c0a19ca04cfe8542ce44487f339d15d89a473b58cea63c0b230217",
+        "size_in_bytes": 8541
+      },
+      {
+        "_path": "Lib/email/_header_value_parser.py",
+        "path_type": "hardlink",
+        "sha256": "c25c893acd0fe385a8ef28e828a73ce224d35ce0f647eec30758b34c85b738db",
+        "sha256_in_prefix": "c25c893acd0fe385a8ef28e828a73ce224d35ce0f647eec30758b34c85b738db",
+        "size_in_bytes": 107205
+      },
+      {
+        "_path": "Lib/email/_parseaddr.py",
+        "path_type": "hardlink",
+        "sha256": "7882ed6e24e319a89b6bbd66691ff11a55600806718aaa391fff26f7bf1f0d5e",
+        "sha256_in_prefix": "7882ed6e24e319a89b6bbd66691ff11a55600806718aaa391fff26f7bf1f0d5e",
+        "size_in_bytes": 17722
+      },
+      {
+        "_path": "Lib/email/_policybase.py",
+        "path_type": "hardlink",
+        "sha256": "3db4bf3be5bdba13ab9a78ce30784c330d6dbc657b4e9142210dc8b264cfd424",
+        "sha256_in_prefix": "3db4bf3be5bdba13ab9a78ce30784c330d6dbc657b4e9142210dc8b264cfd424",
+        "size_in_bytes": 15534
+      },
+      {
+        "_path": "Lib/email/architecture.rst",
+        "path_type": "hardlink",
+        "sha256": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae",
+        "sha256_in_prefix": "f2b2ba7497fd02d13abcfc2a98099283a94b09e8b4f2c1c822ecacde3bec3eae",
+        "size_in_bytes": 9561
+      },
+      {
+        "_path": "Lib/email/base64mime.py",
+        "path_type": "hardlink",
+        "sha256": "1a1bd2d536c77b735892ddf4c6cc6c741184d93c58c11e8f191b5ea29beb753a",
+        "sha256_in_prefix": "1a1bd2d536c77b735892ddf4c6cc6c741184d93c58c11e8f191b5ea29beb753a",
+        "size_in_bytes": 3558
+      },
+      {
+        "_path": "Lib/email/charset.py",
+        "path_type": "hardlink",
+        "sha256": "115cc9aad570643b91897a19c71f7a27028bc11b4ee4374e11a32643c1b12d25",
+        "sha256_in_prefix": "115cc9aad570643b91897a19c71f7a27028bc11b4ee4374e11a32643c1b12d25",
+        "size_in_bytes": 17128
+      },
+      {
+        "_path": "Lib/email/contentmanager.py",
+        "path_type": "hardlink",
+        "sha256": "2b3adab3d945d156bf8a22762590278bbf177d95545e5fc3c1d6c73b5d041ddf",
+        "sha256_in_prefix": "2b3adab3d945d156bf8a22762590278bbf177d95545e5fc3c1d6c73b5d041ddf",
+        "size_in_bytes": 10555
+      },
+      {
+        "_path": "Lib/email/encoders.py",
+        "path_type": "hardlink",
+        "sha256": "1e05b3ee30c62c605077e7770b5b3249f5060d968b0fee8d5cf9cad9450b89cd",
+        "sha256_in_prefix": "1e05b3ee30c62c605077e7770b5b3249f5060d968b0fee8d5cf9cad9450b89cd",
+        "size_in_bytes": 1786
+      },
+      {
+        "_path": "Lib/email/errors.py",
+        "path_type": "hardlink",
+        "sha256": "78592d1189ac8e3ab4a77839512193a9fb6f614d98eaddadf9630ece654a57e9",
+        "sha256_in_prefix": "78592d1189ac8e3ab4a77839512193a9fb6f614d98eaddadf9630ece654a57e9",
+        "size_in_bytes": 3726
+      },
+      {
+        "_path": "Lib/email/feedparser.py",
+        "path_type": "hardlink",
+        "sha256": "6f8faf3d77fbdc2096f8bbedfd58c3d58e7937a11f0d652b43a2b842a5597625",
+        "sha256_in_prefix": "6f8faf3d77fbdc2096f8bbedfd58c3d58e7937a11f0d652b43a2b842a5597625",
+        "size_in_bytes": 22780
+      },
+      {
+        "_path": "Lib/email/generator.py",
+        "path_type": "hardlink",
+        "sha256": "b9595d3b534944d7c0fc80111ee01dd39471c7d6497b0480dca6a25e40082100",
+        "sha256_in_prefix": "b9595d3b534944d7c0fc80111ee01dd39471c7d6497b0480dca6a25e40082100",
+        "size_in_bytes": 20816
+      },
+      {
+        "_path": "Lib/email/header.py",
+        "path_type": "hardlink",
+        "sha256": "99921e2aa7ae5ae1433a0e3f92c732026677417c39923996c11931589ff8a361",
+        "sha256_in_prefix": "99921e2aa7ae5ae1433a0e3f92c732026677417c39923996c11931589ff8a361",
+        "size_in_bytes": 24102
+      },
+      {
+        "_path": "Lib/email/headerregistry.py",
+        "path_type": "hardlink",
+        "sha256": "cc7287a3f062a07243902456098361561066e1f4747b814764ab7d7b905b7494",
+        "sha256_in_prefix": "cc7287a3f062a07243902456098361561066e1f4747b814764ab7d7b905b7494",
+        "size_in_bytes": 20628
+      },
+      {
+        "_path": "Lib/email/iterators.py",
+        "path_type": "hardlink",
+        "sha256": "7ebca15c9f5889b9551727303666a7bd80c5e4ebdf6bc7ec4d0c46938a1378e1",
+        "sha256_in_prefix": "7ebca15c9f5889b9551727303666a7bd80c5e4ebdf6bc7ec4d0c46938a1378e1",
+        "size_in_bytes": 2135
+      },
+      {
+        "_path": "Lib/email/message.py",
+        "path_type": "hardlink",
+        "sha256": "1b125a3f94289c3ff62f4dee59bcc46ded67aa4f759d3dbc035d84ce92d85d1e",
+        "sha256_in_prefix": "1b125a3f94289c3ff62f4dee59bcc46ded67aa4f759d3dbc035d84ce92d85d1e",
+        "size_in_bytes": 47060
+      },
+      {
+        "_path": "Lib/email/mime/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/email/mime/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "310b768a73af14830fd945088117a2effa37511c377635c5746e7a62b4ac966a",
+        "sha256_in_prefix": "310b768a73af14830fd945088117a2effa37511c377635c5746e7a62b4ac966a",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "Lib/email/mime/__pycache__/application.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "209215a95637bdf66b9ff4cf2012c9d9bf05b37a32140c710b0339713acb0501",
+        "sha256_in_prefix": "209215a95637bdf66b9ff4cf2012c9d9bf05b37a32140c710b0339713acb0501",
+        "size_in_bytes": 1444
+      },
+      {
+        "_path": "Lib/email/mime/__pycache__/audio.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "223c217c9416a922bac86ab71818a70d0c7073f5e0f7629db5afbdc1e0c0f3e6",
+        "sha256_in_prefix": "223c217c9416a922bac86ab71818a70d0c7073f5e0f7629db5afbdc1e0c0f3e6",
+        "size_in_bytes": 2609
+      },
+      {
+        "_path": "Lib/email/mime/__pycache__/base.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1422b6b354bc4fa690bf8484d4d17b11e1014a1ccdea4a6a8caf36d660dff393",
+        "sha256_in_prefix": "1422b6b354bc4fa690bf8484d4d17b11e1014a1ccdea4a6a8caf36d660dff393",
+        "size_in_bytes": 1030
+      },
+      {
+        "_path": "Lib/email/mime/__pycache__/image.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aff29e64322af78c111215c2b2071ad2ea18c5c6d3faee16350e06a26125dda8",
+        "sha256_in_prefix": "aff29e64322af78c111215c2b2071ad2ea18c5c6d3faee16350e06a26125dda8",
+        "size_in_bytes": 1889
+      },
+      {
+        "_path": "Lib/email/mime/__pycache__/message.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "803971ee621b3e9d03d6c95b26097cf61a1e91cd125fbaaac8d9a41c8fe978b9",
+        "sha256_in_prefix": "803971ee621b3e9d03d6c95b26097cf61a1e91cd125fbaaac8d9a41c8fe978b9",
+        "size_in_bytes": 1267
+      },
+      {
+        "_path": "Lib/email/mime/__pycache__/multipart.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ef7d11a95442d711237cd0f7e1d77ea7e51f670c1b7d2f639da145211b5a5b9b",
+        "sha256_in_prefix": "ef7d11a95442d711237cd0f7e1d77ea7e51f670c1b7d2f639da145211b5a5b9b",
+        "size_in_bytes": 1487
+      },
+      {
+        "_path": "Lib/email/mime/__pycache__/nonmultipart.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f1b51b6992e25e19947d4897204b871440630da112d1d8308b8d86d2e3cfe819",
+        "sha256_in_prefix": "f1b51b6992e25e19947d4897204b871440630da112d1d8308b8d86d2e3cfe819",
+        "size_in_bytes": 749
+      },
+      {
+        "_path": "Lib/email/mime/__pycache__/text.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "23692acbbaf4a7a6bcf1cc4bd60771197c0a8cf895324e90c3b72927e63b4983",
+        "sha256_in_prefix": "23692acbbaf4a7a6bcf1cc4bd60771197c0a8cf895324e90c3b72927e63b4983",
+        "size_in_bytes": 1294
+      },
+      {
+        "_path": "Lib/email/mime/application.py",
+        "path_type": "hardlink",
+        "sha256": "5cd0255a621e87867c3c7f5130e0f3468eff99278e859320fcd07619cb5a35d8",
+        "sha256_in_prefix": "5cd0255a621e87867c3c7f5130e0f3468eff99278e859320fcd07619cb5a35d8",
+        "size_in_bytes": 1321
+      },
+      {
+        "_path": "Lib/email/mime/audio.py",
+        "path_type": "hardlink",
+        "sha256": "427778cece4effa17e21ea53e9946b146c9d70d7252473a0745cafb621fbafb5",
+        "sha256_in_prefix": "427778cece4effa17e21ea53e9946b146c9d70d7252473a0745cafb621fbafb5",
+        "size_in_bytes": 2739
+      },
+      {
+        "_path": "Lib/email/mime/base.py",
+        "path_type": "hardlink",
+        "sha256": "8e1014770d0d5e9fe6207ae0919b572033e4acc75e961ea0a3f760547716e3ee",
+        "sha256_in_prefix": "8e1014770d0d5e9fe6207ae0919b572033e4acc75e961ea0a3f760547716e3ee",
+        "size_in_bytes": 916
+      },
+      {
+        "_path": "Lib/email/mime/image.py",
+        "path_type": "hardlink",
+        "sha256": "a7aa3adaa32627323d5aa9d07228665a5d6492d2b392eb7bb36de752cd0972ee",
+        "sha256_in_prefix": "a7aa3adaa32627323d5aa9d07228665a5d6492d2b392eb7bb36de752cd0972ee",
+        "size_in_bytes": 1829
+      },
+      {
+        "_path": "Lib/email/mime/message.py",
+        "path_type": "hardlink",
+        "sha256": "0553e0365eb7e58ba8dcd5f4d416af8ab331b5d6d920b6fb16481ed172fa7d79",
+        "sha256_in_prefix": "0553e0365eb7e58ba8dcd5f4d416af8ab331b5d6d920b6fb16481ed172fa7d79",
+        "size_in_bytes": 1317
+      },
+      {
+        "_path": "Lib/email/mime/multipart.py",
+        "path_type": "hardlink",
+        "sha256": "53730a1a7807d8af12b88665d8f474f48bf39ed1ef4c47433267a44ef54b0ba7",
+        "sha256_in_prefix": "53730a1a7807d8af12b88665d8f474f48bf39ed1ef4c47433267a44ef54b0ba7",
+        "size_in_bytes": 1621
+      },
+      {
+        "_path": "Lib/email/mime/nonmultipart.py",
+        "path_type": "hardlink",
+        "sha256": "1f6fdedb5ba3e0a698bf33d77e329fc4cf2ab4305474b6ae23c1bc0f99daaf7a",
+        "sha256_in_prefix": "1f6fdedb5ba3e0a698bf33d77e329fc4cf2ab4305474b6ae23c1bc0f99daaf7a",
+        "size_in_bytes": 691
+      },
+      {
+        "_path": "Lib/email/mime/text.py",
+        "path_type": "hardlink",
+        "sha256": "aa903b8248020e9211e88f2c3a5e3a05f6969b6aab2b6f01ea1ddff776b870de",
+        "sha256_in_prefix": "aa903b8248020e9211e88f2c3a5e3a05f6969b6aab2b6f01ea1ddff776b870de",
+        "size_in_bytes": 1437
+      },
+      {
+        "_path": "Lib/email/parser.py",
+        "path_type": "hardlink",
+        "sha256": "eab481ca55902fae679fa2f794c8a81f913723d5029a79d9eb806d4b0c6b6b49",
+        "sha256_in_prefix": "eab481ca55902fae679fa2f794c8a81f913723d5029a79d9eb806d4b0c6b6b49",
+        "size_in_bytes": 5041
+      },
+      {
+        "_path": "Lib/email/policy.py",
+        "path_type": "hardlink",
+        "sha256": "ca1b94f27db711094e9ba3ec4419313c3e660d1016f4bf01d467e5a174bb6302",
+        "sha256_in_prefix": "ca1b94f27db711094e9ba3ec4419313c3e660d1016f4bf01d467e5a174bb6302",
+        "size_in_bytes": 10383
+      },
+      {
+        "_path": "Lib/email/quoprimime.py",
+        "path_type": "hardlink",
+        "sha256": "3b892900fd55b57d3be22f7bc9696feb905545adb81d37f4b77166753473a4b4",
+        "sha256_in_prefix": "3b892900fd55b57d3be22f7bc9696feb905545adb81d37f4b77166753473a4b4",
+        "size_in_bytes": 9858
+      },
+      {
+        "_path": "Lib/email/utils.py",
+        "path_type": "hardlink",
+        "sha256": "545434b279e2c507e0f005bf8c6cde2259b0d3c5e158d999e7f15be3d27675c8",
+        "sha256_in_prefix": "545434b279e2c507e0f005bf8c6cde2259b0d3c5e158d999e7f15be3d27675c8",
+        "size_in_bytes": 17060
+      },
+      {
+        "_path": "Lib/encodings/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "57ce0008389d686b1363abbf2ebb529435942eda457297b179f2eba7db4e8582",
+        "sha256_in_prefix": "57ce0008389d686b1363abbf2ebb529435942eda457297b179f2eba7db4e8582",
+        "size_in_bytes": 5588
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7360c30757b215d46a3f7317e0b65b266565771cb4406996891bb1e35b45a87f",
+        "sha256_in_prefix": "7360c30757b215d46a3f7317e0b65b266565771cb4406996891bb1e35b45a87f",
+        "size_in_bytes": 3880
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/aliases.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0ec361690be3fa66a42e329ef5cf1a9d5d97874cb10c6b6abfb29a288fea2986",
+        "sha256_in_prefix": "0ec361690be3fa66a42e329ef5cf1a9d5d97874cb10c6b6abfb29a288fea2986",
+        "size_in_bytes": 6313
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/ascii.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5cc4d5a679f909641fd2cfee3706f37ebc2ab4e4f5754302b2787649bdcf4a9a",
+        "sha256_in_prefix": "5cc4d5a679f909641fd2cfee3706f37ebc2ab4e4f5754302b2787649bdcf4a9a",
+        "size_in_bytes": 1866
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/base64_codec.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2ad42110e1307d1d2f63638ee4388f34f1f7fac6cece70f6bff148abce03e6ae",
+        "sha256_in_prefix": "2ad42110e1307d1d2f63638ee4388f34f1f7fac6cece70f6bff148abce03e6ae",
+        "size_in_bytes": 2353
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/big5.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3de4d9f69f8bd9a4f0c9711a178741076d880bde16e2009e394754f88e881a3e",
+        "sha256_in_prefix": "3de4d9f69f8bd9a4f0c9711a178741076d880bde16e2009e394754f88e881a3e",
+        "size_in_bytes": 1394
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/big5hkscs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b15a9b310e338f292e24f9a94a89fa41454538336f6bc8fcf9d46b1fe8ea6ed8",
+        "sha256_in_prefix": "b15a9b310e338f292e24f9a94a89fa41454538336f6bc8fcf9d46b1fe8ea6ed8",
+        "size_in_bytes": 1404
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/bz2_codec.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0c8789d48ab327238745b4b891ae8784a46985547992bb1fb58d1592e9afafbc",
+        "sha256_in_prefix": "0c8789d48ab327238745b4b891ae8784a46985547992bb1fb58d1592e9afafbc",
+        "size_in_bytes": 3242
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/charmap.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "621549b675f89f9fbfe5b122ed911e93c36ecc0d83d37a4b99ee9102d877b1ae",
+        "sha256_in_prefix": "621549b675f89f9fbfe5b122ed911e93c36ecc0d83d37a4b99ee9102d877b1ae",
+        "size_in_bytes": 2876
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp037.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "069ee23970232f966759d6619584a6c3380f451705139eea3d1f7a0e3f003b3f",
+        "sha256_in_prefix": "069ee23970232f966759d6619584a6c3380f451705139eea3d1f7a0e3f003b3f",
+        "size_in_bytes": 2407
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1006.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aa6dd66ecbd9c36b7776cacdcbc3c1e40f5939900ac435401efd6f7759f521be",
+        "sha256_in_prefix": "aa6dd66ecbd9c36b7776cacdcbc3c1e40f5939900ac435401efd6f7759f521be",
+        "size_in_bytes": 2483
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1026.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e59d20d8f62b52815dbe8199856594ffe93230c4e082b852304c947831e7c747",
+        "sha256_in_prefix": "e59d20d8f62b52815dbe8199856594ffe93230c4e082b852304c947831e7c747",
+        "size_in_bytes": 2411
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1125.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b6873fe68d078d2aa32cb8a9d9a5a892647ee2a2629e0a9ce565cd08e5a3ebb3",
+        "sha256_in_prefix": "b6873fe68d078d2aa32cb8a9d9a5a892647ee2a2629e0a9ce565cd08e5a3ebb3",
+        "size_in_bytes": 8114
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1140.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d61e691acbf9210ca3309333a45548baee9e4bdc1e7b4b4c46743c02055bfb4c",
+        "sha256_in_prefix": "d61e691acbf9210ca3309333a45548baee9e4bdc1e7b4b4c46743c02055bfb4c",
+        "size_in_bytes": 2397
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1250.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6e03e7da6841179a990af88d75838fd8c63b9f4cd53a2aff8f0cfbdfeeb128a8",
+        "sha256_in_prefix": "6e03e7da6841179a990af88d75838fd8c63b9f4cd53a2aff8f0cfbdfeeb128a8",
+        "size_in_bytes": 2434
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1251.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d8d7b96b15f950ba007a8ef0ad4144222a44ec1c09b96ef1cc722f53ef599ea7",
+        "sha256_in_prefix": "d8d7b96b15f950ba007a8ef0ad4144222a44ec1c09b96ef1cc722f53ef599ea7",
+        "size_in_bytes": 2431
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1252.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "11ddfe56189af46efdc1e9aa4fc499a14dc3017dba9ca401f38c775143fa5f46",
+        "sha256_in_prefix": "11ddfe56189af46efdc1e9aa4fc499a14dc3017dba9ca401f38c775143fa5f46",
+        "size_in_bytes": 2434
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1253.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "56f3c70dc1a8545e0e5b9dbedb671bf0216b46b954b636bc6ae24301bc55477b",
+        "sha256_in_prefix": "56f3c70dc1a8545e0e5b9dbedb671bf0216b46b954b636bc6ae24301bc55477b",
+        "size_in_bytes": 2447
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1254.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2e0e7a4c312ba215d2fca19e5a4b6d3b79639606359b3bdd7b58c215f5527120",
+        "sha256_in_prefix": "2e0e7a4c312ba215d2fca19e5a4b6d3b79639606359b3bdd7b58c215f5527120",
+        "size_in_bytes": 2436
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1255.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4fefd3ab881022de86d324aaf370cc8ae5f4bed0c8d8d2f61acb82c0f0fa1ea0",
+        "sha256_in_prefix": "4fefd3ab881022de86d324aaf370cc8ae5f4bed0c8d8d2f61acb82c0f0fa1ea0",
+        "size_in_bytes": 2455
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1256.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c93bcb933b672294bcf281a79c80d7448d55b605168fb7b720629b2d65fa42cd",
+        "sha256_in_prefix": "c93bcb933b672294bcf281a79c80d7448d55b605168fb7b720629b2d65fa42cd",
+        "size_in_bytes": 2433
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1257.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "74098365d456f4ec717934c6390af11424c8987a2410678cd7051c659bd0f965",
+        "sha256_in_prefix": "74098365d456f4ec717934c6390af11424c8987a2410678cd7051c659bd0f965",
+        "size_in_bytes": 2441
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp1258.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1cc9da4a40caa5eea29e16978de97508e58bfd59bf1af832223187c49f821060",
+        "sha256_in_prefix": "1cc9da4a40caa5eea29e16978de97508e58bfd59bf1af832223187c49f821060",
+        "size_in_bytes": 2439
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp273.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1b3b35a2555d3d813b1699c611711ec9d6e390ced8db2cfbac777b16471e330d",
+        "sha256_in_prefix": "1b3b35a2555d3d813b1699c611711ec9d6e390ced8db2cfbac777b16471e330d",
+        "size_in_bytes": 2393
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp424.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "abcfabb37e34c2bcf5cb6f5ece2438f9049c68193c9c832c3b65f6e714dc8e8b",
+        "sha256_in_prefix": "abcfabb37e34c2bcf5cb6f5ece2438f9049c68193c9c832c3b65f6e714dc8e8b",
+        "size_in_bytes": 2437
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp437.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2486674233fd951a9c5ec158fe5c8269924ee29492e8128c3600ab629721602d",
+        "sha256_in_prefix": "2486674233fd951a9c5ec158fe5c8269924ee29492e8128c3600ab629721602d",
+        "size_in_bytes": 7831
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp500.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3d8ee4e8d931821ab71f095fa6dc4a94ebb5569be5566c43d9d2f6391135a117",
+        "sha256_in_prefix": "3d8ee4e8d931821ab71f095fa6dc4a94ebb5569be5566c43d9d2f6391135a117",
+        "size_in_bytes": 2407
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp720.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "601590efd64b6a03d2c02cc93ccbb600d88516805e7ced946a8397251a0f9504",
+        "sha256_in_prefix": "601590efd64b6a03d2c02cc93ccbb600d88516805e7ced946a8397251a0f9504",
+        "size_in_bytes": 2504
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp737.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "07c9f42975a601405d4d894f42612fa7165fbbbf1c22a75721045c07d8cf5214",
+        "sha256_in_prefix": "07c9f42975a601405d4d894f42612fa7165fbbbf1c22a75721045c07d8cf5214",
+        "size_in_bytes": 8153
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp775.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f9202312b9547b5dc8d8d164a1ea8f9f73913c9099df4d334e8cbcb6b728dbec",
+        "sha256_in_prefix": "f9202312b9547b5dc8d8d164a1ea8f9f73913c9099df4d334e8cbcb6b728dbec",
+        "size_in_bytes": 7861
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp850.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e324f9d3899b51a361f49b440eaeea2d12dc07f8312ea0c23da56bbfdf899779",
+        "sha256_in_prefix": "e324f9d3899b51a361f49b440eaeea2d12dc07f8312ea0c23da56bbfdf899779",
+        "size_in_bytes": 7492
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp852.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c02b61d0b928b8625e5f94f46711cb7a980de49f5bf70aba982c62e460325977",
+        "sha256_in_prefix": "c02b61d0b928b8625e5f94f46711cb7a980de49f5bf70aba982c62e460325977",
+        "size_in_bytes": 7869
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp855.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ab55e192e78733a433eca54ded294378a4f3c5024a18497c19d5d4c48e896f9d",
+        "sha256_in_prefix": "ab55e192e78733a433eca54ded294378a4f3c5024a18497c19d5d4c48e896f9d",
+        "size_in_bytes": 8122
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp856.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "be30d35eb5fe5ba7352bab1f9facb3b8eb32d893fc3a804f3657b742259d87bd",
+        "sha256_in_prefix": "be30d35eb5fe5ba7352bab1f9facb3b8eb32d893fc3a804f3657b742259d87bd",
+        "size_in_bytes": 2469
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp857.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f96115c5e658aee4e7b6d85243f0a966aeb80d7ea9eb3e6549c1286631fc6bef",
+        "sha256_in_prefix": "f96115c5e658aee4e7b6d85243f0a966aeb80d7ea9eb3e6549c1286631fc6bef",
+        "size_in_bytes": 7472
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp858.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9fc46c0a75238577ebe5ab4663d97e70fcf3569cece3887b3ef2b7a9a3686172",
+        "sha256_in_prefix": "9fc46c0a75238577ebe5ab4663d97e70fcf3569cece3887b3ef2b7a9a3686172",
+        "size_in_bytes": 7462
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp860.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "80767469f4b9d3483f7b328fe606d8273c3870ada4d230b31fbd1e12b7698c0a",
+        "sha256_in_prefix": "80767469f4b9d3483f7b328fe606d8273c3870ada4d230b31fbd1e12b7698c0a",
+        "size_in_bytes": 7810
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp861.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "023e7c3eec1fb61eacb39c0d99d943ffeedfff518c3369d41fd66231dee00c58",
+        "sha256_in_prefix": "023e7c3eec1fb61eacb39c0d99d943ffeedfff518c3369d41fd66231dee00c58",
+        "size_in_bytes": 7825
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp862.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d598e0547c44690f5bdcff5743587ebe32fb31ca6ec49d50740a44dd9f10a9fe",
+        "sha256_in_prefix": "d598e0547c44690f5bdcff5743587ebe32fb31ca6ec49d50740a44dd9f10a9fe",
+        "size_in_bytes": 8014
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp863.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0d2a68876715d98538dd2411b19a0da51c708f84358e282a9140a68c695cce9d",
+        "sha256_in_prefix": "0d2a68876715d98538dd2411b19a0da51c708f84358e282a9140a68c695cce9d",
+        "size_in_bytes": 7825
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp864.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d9e3cca691962e2208151f477f94081b5e62d23f907a08fa04640f9d1dcf1b19",
+        "sha256_in_prefix": "d9e3cca691962e2208151f477f94081b5e62d23f907a08fa04640f9d1dcf1b19",
+        "size_in_bytes": 7969
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp865.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "86c3ed9df1139d72bf70eaa8b475fad033a6a2d8e10cb7c85cfda268a53add54",
+        "sha256_in_prefix": "86c3ed9df1139d72bf70eaa8b475fad033a6a2d8e10cb7c85cfda268a53add54",
+        "size_in_bytes": 7825
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp866.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a0a9a97b8f5be7fa94179cf660464e39811e35a7aa6eb7045b67d3681887b0a2",
+        "sha256_in_prefix": "a0a9a97b8f5be7fa94179cf660464e39811e35a7aa6eb7045b67d3681887b0a2",
+        "size_in_bytes": 8158
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp869.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c317f0b2565d0b263bdfcb0890c4b071e9fb1d40017746ac1a38954a4db8a3c2",
+        "sha256_in_prefix": "c317f0b2565d0b263bdfcb0890c4b071e9fb1d40017746ac1a38954a4db8a3c2",
+        "size_in_bytes": 7849
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp874.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5a65ad4a5c559aa0ae767348582bf61ac625bbea2f592ac0ae5325b701d3c038",
+        "sha256_in_prefix": "5a65ad4a5c559aa0ae767348582bf61ac625bbea2f592ac0ae5325b701d3c038",
+        "size_in_bytes": 2535
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp875.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "82970ea211d6560e87b01f04ef88b8bc631c266197b471c9e851be83f1f8eb4b",
+        "sha256_in_prefix": "82970ea211d6560e87b01f04ef88b8bc631c266197b471c9e851be83f1f8eb4b",
+        "size_in_bytes": 2404
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp932.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fa0e61f7481b88d2ec5663974ba9b75bb2c92daa70163aa88acd89a78cf59a69",
+        "sha256_in_prefix": "fa0e61f7481b88d2ec5663974ba9b75bb2c92daa70163aa88acd89a78cf59a69",
+        "size_in_bytes": 1396
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp949.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c812b9d33be8a59e178f731393ef3ebf1ebdafd709d664c2f25941d4bd152691",
+        "sha256_in_prefix": "c812b9d33be8a59e178f731393ef3ebf1ebdafd709d664c2f25941d4bd152691",
+        "size_in_bytes": 1396
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/cp950.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bdfe21aa0b3a3ec5ac59bbd510b5e9388a8041f66617bc1ffeeb2f6617edd1ea",
+        "sha256_in_prefix": "bdfe21aa0b3a3ec5ac59bbd510b5e9388a8041f66617bc1ffeeb2f6617edd1ea",
+        "size_in_bytes": 1396
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/euc_jis_2004.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "79d20b1ee82bdf4d7261ceba30ccbdbde843cfc8dca6a39566e83904df4427eb",
+        "sha256_in_prefix": "79d20b1ee82bdf4d7261ceba30ccbdbde843cfc8dca6a39566e83904df4427eb",
+        "size_in_bytes": 1410
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/euc_jisx0213.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6db368385d6f6cc205d9524d892aadc2b1d652b3cd7ccb401317d9efef332dd7",
+        "sha256_in_prefix": "6db368385d6f6cc205d9524d892aadc2b1d652b3cd7ccb401317d9efef332dd7",
+        "size_in_bytes": 1410
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/euc_jp.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ec0f341c84b8872b925d30b9f6bff6d7581d6e9b2aee680f54ff531506f6beda",
+        "sha256_in_prefix": "ec0f341c84b8872b925d30b9f6bff6d7581d6e9b2aee680f54ff531506f6beda",
+        "size_in_bytes": 1398
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/euc_kr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d0adbf19e14acd0fc4d4fde292896fc18825b77310be162c39127f03c7f592b2",
+        "sha256_in_prefix": "d0adbf19e14acd0fc4d4fde292896fc18825b77310be162c39127f03c7f592b2",
+        "size_in_bytes": 1398
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/gb18030.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7dd8d773d0d61d11b3025c0f072af37f48b9699826fde32149f98f53acbf9231",
+        "sha256_in_prefix": "7dd8d773d0d61d11b3025c0f072af37f48b9699826fde32149f98f53acbf9231",
+        "size_in_bytes": 1400
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/gb2312.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "30da50d58d8551ed3e1b5ce361bdb234229e9f4f5e77f3076dc2ab01ecf90293",
+        "sha256_in_prefix": "30da50d58d8551ed3e1b5ce361bdb234229e9f4f5e77f3076dc2ab01ecf90293",
+        "size_in_bytes": 1398
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/gbk.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6558afac3e8dec58bd1f5e360cb711f6f0cff884e1df994a19c2fbdbe678f498",
+        "sha256_in_prefix": "6558afac3e8dec58bd1f5e360cb711f6f0cff884e1df994a19c2fbdbe678f498",
+        "size_in_bytes": 1392
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/hex_codec.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "71c163c13f435ad329dcf13df0aa091863736931f3021de2ce8939cc948255a4",
+        "sha256_in_prefix": "71c163c13f435ad329dcf13df0aa091863736931f3021de2ce8939cc948255a4",
+        "size_in_bytes": 2340
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/hp_roman8.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "32fff0aeefdee8e558fcc1abe0ed93a43cf7e07f353ab7052faeaacaec2892da",
+        "sha256_in_prefix": "32fff0aeefdee8e558fcc1abe0ed93a43cf7e07f353ab7052faeaacaec2892da",
+        "size_in_bytes": 2608
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/hz.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "00da5d0cb399064b21848f9841f03ccf42572a8e83761c47d4d117115aa81628",
+        "sha256_in_prefix": "00da5d0cb399064b21848f9841f03ccf42572a8e83761c47d4d117115aa81628",
+        "size_in_bytes": 1390
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/idna.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c09aa5edbb92fff00d8884bd81e85193f6b990ac86ec8015ce7f9d1b17e8cbee",
+        "sha256_in_prefix": "c09aa5edbb92fff00d8884bd81e85193f6b990ac86ec8015ce7f9d1b17e8cbee",
+        "size_in_bytes": 5574
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso2022_jp.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "349180dd8deba6907b87898bcada41cce603c8ee610e0ab1ad0fb4d340093751",
+        "sha256_in_prefix": "349180dd8deba6907b87898bcada41cce603c8ee610e0ab1ad0fb4d340093751",
+        "size_in_bytes": 1411
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso2022_jp_1.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4e22266ea952be168a3b63c889ef0bf018772dfa553f18a4609aa2a11cddae7e",
+        "sha256_in_prefix": "4e22266ea952be168a3b63c889ef0bf018772dfa553f18a4609aa2a11cddae7e",
+        "size_in_bytes": 1415
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso2022_jp_2.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "10d8dc58c96e437b1a711787c2bb4b013568705358d6ebde83e68f9f4b9cc3d1",
+        "sha256_in_prefix": "10d8dc58c96e437b1a711787c2bb4b013568705358d6ebde83e68f9f4b9cc3d1",
+        "size_in_bytes": 1415
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso2022_jp_2004.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d0b547cd1969bc9640193855cf89f6f565a69699d371cf9f3ec8bac610471f4f",
+        "sha256_in_prefix": "d0b547cd1969bc9640193855cf89f6f565a69699d371cf9f3ec8bac610471f4f",
+        "size_in_bytes": 1421
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso2022_jp_3.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c7ee3a3e583785c3b284020c6902782b72a298b0002baec884f87a1fb361e92f",
+        "sha256_in_prefix": "c7ee3a3e583785c3b284020c6902782b72a298b0002baec884f87a1fb361e92f",
+        "size_in_bytes": 1415
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso2022_jp_ext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a710ce0913c4d4c22db6f58ec02281e0e18c1d4f838810dfc45c80cbaabf0d8e",
+        "sha256_in_prefix": "a710ce0913c4d4c22db6f58ec02281e0e18c1d4f838810dfc45c80cbaabf0d8e",
+        "size_in_bytes": 1419
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso2022_kr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1562e1c0eadae7a626aa97f491a863ff9a42794bc181e6524826cdbf2c789ba1",
+        "sha256_in_prefix": "1562e1c0eadae7a626aa97f491a863ff9a42794bc181e6524826cdbf2c789ba1",
+        "size_in_bytes": 1411
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_1.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dc89d7f44a837c70c860c83e1f106c4877c84db7b18c226d1ef339e2dd51cb40",
+        "sha256_in_prefix": "dc89d7f44a837c70c860c83e1f106c4877c84db7b18c226d1ef339e2dd51cb40",
+        "size_in_bytes": 2406
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_10.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b51d9dae39f7c3ec82e7549bae0c0073af923a0928e13154166a8c5563ea1d8b",
+        "sha256_in_prefix": "b51d9dae39f7c3ec82e7549bae0c0073af923a0928e13154166a8c5563ea1d8b",
+        "size_in_bytes": 2411
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_11.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "67620f0c2a5c214ba4c9c9e1e977b938284a0c2822fcec257730e8c89ed3183e",
+        "sha256_in_prefix": "67620f0c2a5c214ba4c9c9e1e977b938284a0c2822fcec257730e8c89ed3183e",
+        "size_in_bytes": 2505
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_13.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0564dfea4f87b8a1fdeae3939547de85037379b115c01921937017fa9e2f9c09",
+        "sha256_in_prefix": "0564dfea4f87b8a1fdeae3939547de85037379b115c01921937017fa9e2f9c09",
+        "size_in_bytes": 2414
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_14.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "634ad78855dc38733f41b893c0f65b57f3c6c88c78271e5fc63851c60cf96213",
+        "sha256_in_prefix": "634ad78855dc38733f41b893c0f65b57f3c6c88c78271e5fc63851c60cf96213",
+        "size_in_bytes": 2432
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_15.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8f4709a4f61c8d0439cded42692ca7128ec743423a4711c9addfc24f4cd6a8d7",
+        "sha256_in_prefix": "8f4709a4f61c8d0439cded42692ca7128ec743423a4711c9addfc24f4cd6a8d7",
+        "size_in_bytes": 2411
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_16.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "61c0e606dab276b95265ac9b8f81b01b22766f2f62e7cf0ef2a9432d34355237",
+        "sha256_in_prefix": "61c0e606dab276b95265ac9b8f81b01b22766f2f62e7cf0ef2a9432d34355237",
+        "size_in_bytes": 2413
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_2.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "09e4f72d9b7f42069692c8fc72c05b551e0089a390cd239457228ae73fd921ac",
+        "sha256_in_prefix": "09e4f72d9b7f42069692c8fc72c05b551e0089a390cd239457228ae73fd921ac",
+        "size_in_bytes": 2406
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_3.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0c65ccc0853b2d66c5b8d3a8c24d2415565c9b5c21c6679e19be95ecaf8bf95e",
+        "sha256_in_prefix": "0c65ccc0853b2d66c5b8d3a8c24d2415565c9b5c21c6679e19be95ecaf8bf95e",
+        "size_in_bytes": 2413
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_4.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cc88588837086707fe5b59062b2cca7db45c8d7dac3077e37c0e3dc5b3fedf3f",
+        "sha256_in_prefix": "cc88588837086707fe5b59062b2cca7db45c8d7dac3077e37c0e3dc5b3fedf3f",
+        "size_in_bytes": 2406
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_5.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ec3d984231493368b7a7bd56a0087d5bbb23c4ce2f2ae97f6b7a2d61bd88d810",
+        "sha256_in_prefix": "ec3d984231493368b7a7bd56a0087d5bbb23c4ce2f2ae97f6b7a2d61bd88d810",
+        "size_in_bytes": 2407
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_6.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1e2812e82cf28c5090bf2b8ba8548e980219774323fcfd031bb757d39ef1c61c",
+        "sha256_in_prefix": "1e2812e82cf28c5090bf2b8ba8548e980219774323fcfd031bb757d39ef1c61c",
+        "size_in_bytes": 2451
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_7.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fc487f3b00f758f087bb6001d9ea8a80c5f788c8bb8973229ec4ab11d431c5f9",
+        "sha256_in_prefix": "fc487f3b00f758f087bb6001d9ea8a80c5f788c8bb8973229ec4ab11d431c5f9",
+        "size_in_bytes": 2414
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_8.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "14ca326f52daa4d4e77819342cc54354944885c1228364b3509d07deb0ea2e0c",
+        "sha256_in_prefix": "14ca326f52daa4d4e77819342cc54354944885c1228364b3509d07deb0ea2e0c",
+        "size_in_bytes": 2445
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/iso8859_9.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "db9033223de68d3e48ca24f4b8ccebd319ad177d31852a50911b7010b4014a7c",
+        "sha256_in_prefix": "db9033223de68d3e48ca24f4b8ccebd319ad177d31852a50911b7010b4014a7c",
+        "size_in_bytes": 2406
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/johab.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "787cfa249f41da39d8db51b8eeb1af92c46429c967c5dc10f60e1855e28983b9",
+        "sha256_in_prefix": "787cfa249f41da39d8db51b8eeb1af92c46429c967c5dc10f60e1855e28983b9",
+        "size_in_bytes": 1396
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/koi8_r.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "30db2f4833c54bd62ee5f7bae610c68c680a7f9ed0a21f03f4d53a03bf1eb370",
+        "sha256_in_prefix": "30db2f4833c54bd62ee5f7bae610c68c680a7f9ed0a21f03f4d53a03bf1eb370",
+        "size_in_bytes": 2458
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/koi8_t.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "47f3a21bf170353a6621a824e4a69f9d5264f78e88fa53088e2a42aecbc61e05",
+        "sha256_in_prefix": "47f3a21bf170353a6621a824e4a69f9d5264f78e88fa53088e2a42aecbc61e05",
+        "size_in_bytes": 2369
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/koi8_u.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6eb94083de334cbd1467ef596fffb05933454ce731d1b5b6de0bfefc3770c878",
+        "sha256_in_prefix": "6eb94083de334cbd1467ef596fffb05933454ce731d1b5b6de0bfefc3770c878",
+        "size_in_bytes": 2444
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/kz1048.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3a83b956b7483407165abc45b782a498ce452271069724b5e4207cfd7f6a4d01",
+        "sha256_in_prefix": "3a83b956b7483407165abc45b782a498ce452271069724b5e4207cfd7f6a4d01",
+        "size_in_bytes": 2421
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/latin_1.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c462347320468c9cd80743a5707a63eb91b8846a261c03d5f5085fa4e72de157",
+        "sha256_in_prefix": "c462347320468c9cd80743a5707a63eb91b8846a261c03d5f5085fa4e72de157",
+        "size_in_bytes": 1878
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_arabic.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f12ea80675a5b75d7017f0896f40bae91d5945c7497d75731c656d96b7769419",
+        "sha256_in_prefix": "f12ea80675a5b75d7017f0896f40bae91d5945c7497d75731c656d96b7769419",
+        "size_in_bytes": 7725
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_croatian.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6684e8f6a4949f6f578e435b6511bca85201089132c0d3cbbd83510df0e5b9c9",
+        "sha256_in_prefix": "6684e8f6a4949f6f578e435b6511bca85201089132c0d3cbbd83510df0e5b9c9",
+        "size_in_bytes": 2453
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_cyrillic.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "30d5254ab3d68ea82b8f2529e7a46ecd12cf80b6ddc04964cb08a13639c6c98e",
+        "sha256_in_prefix": "30d5254ab3d68ea82b8f2529e7a46ecd12cf80b6ddc04964cb08a13639c6c98e",
+        "size_in_bytes": 2443
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_farsi.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ea6dd045b54573518023dd6d1671983b19d67d14eb1a5a8a5c5721dee469cbcd",
+        "sha256_in_prefix": "ea6dd045b54573518023dd6d1671983b19d67d14eb1a5a8a5c5721dee469cbcd",
+        "size_in_bytes": 2387
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_greek.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "144b7468b1a92959dbad50a1758becb70a270c36ca30ac8c76c568449971a5b5",
+        "sha256_in_prefix": "144b7468b1a92959dbad50a1758becb70a270c36ca30ac8c76c568449971a5b5",
+        "size_in_bytes": 2427
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_iceland.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d3913fd0805c4cc74117e7f908fa8c0031459a61293ed00a4e9d0eec6c9eb913",
+        "sha256_in_prefix": "d3913fd0805c4cc74117e7f908fa8c0031459a61293ed00a4e9d0eec6c9eb913",
+        "size_in_bytes": 2446
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_latin2.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8055e69bde9ef9b7afd2b66b9e877fc35110cbd148775d92ac4adf6ba82fa534",
+        "sha256_in_prefix": "8055e69bde9ef9b7afd2b66b9e877fc35110cbd148775d92ac4adf6ba82fa534",
+        "size_in_bytes": 2587
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_roman.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a91a0f1d67e7b264626fe52f2c1014ba64f16a2db5ce5d8fa25af2c371e5dad5",
+        "sha256_in_prefix": "a91a0f1d67e7b264626fe52f2c1014ba64f16a2db5ce5d8fa25af2c371e5dad5",
+        "size_in_bytes": 2444
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_romanian.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "655cbc06b761ab38470fe4f383ee492eb79eb49b649fe94e2732ecafc5d5bbfd",
+        "sha256_in_prefix": "655cbc06b761ab38470fe4f383ee492eb79eb49b649fe94e2732ecafc5d5bbfd",
+        "size_in_bytes": 2454
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mac_turkish.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cbb71a3e5fab5edefd01f3a0831d1badbb4e55a3046311eee5164ee68f8faf24",
+        "sha256_in_prefix": "cbb71a3e5fab5edefd01f3a0831d1badbb4e55a3046311eee5164ee68f8faf24",
+        "size_in_bytes": 2447
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/mbcs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c1bfce1a94f348569297b79d6b3dbf12bbdb4aff869014de6bd5b2aa9f2ed6dc",
+        "sha256_in_prefix": "c1bfce1a94f348569297b79d6b3dbf12bbdb4aff869014de6bd5b2aa9f2ed6dc",
+        "size_in_bytes": 1696
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/oem.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a0f350b14d9ff6f66c0b6935f770a2360828bc53c4ccfbcd1811fae00d031930",
+        "sha256_in_prefix": "a0f350b14d9ff6f66c0b6935f770a2360828bc53c4ccfbcd1811fae00d031930",
+        "size_in_bytes": 1509
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/palmos.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "646e2db055135044e42c726176ef453b127b73304b4732ba6c51a7c241c5d59e",
+        "sha256_in_prefix": "646e2db055135044e42c726176ef453b127b73304b4732ba6c51a7c241c5d59e",
+        "size_in_bytes": 2434
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/ptcp154.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "947d2f52a94171ad07662dbc31b8be88742a35f75e7f403c8176daabbd2ca886",
+        "sha256_in_prefix": "947d2f52a94171ad07662dbc31b8be88742a35f75e7f403c8176daabbd2ca886",
+        "size_in_bytes": 2528
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/punycode.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6487f2cf65bf4241c486f74942c05346f30f005bd1787dadc4b21559c49c89d5",
+        "sha256_in_prefix": "6487f2cf65bf4241c486f74942c05346f30f005bd1787dadc4b21559c49c89d5",
+        "size_in_bytes": 6292
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/quopri_codec.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "379aa73b85f16d3f879ba228c49eff8dd0ba109de081895e92bbbeda2b78435a",
+        "sha256_in_prefix": "379aa73b85f16d3f879ba228c49eff8dd0ba109de081895e92bbbeda2b78435a",
+        "size_in_bytes": 2379
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/raw_unicode_escape.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "feea11fe992a43c5acd42af19860eff562ac6f376660895296da1d3393d446ae",
+        "sha256_in_prefix": "feea11fe992a43c5acd42af19860eff562ac6f376660895296da1d3393d446ae",
+        "size_in_bytes": 1958
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/rot_13.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "497cb28efabb2e321f9621aa23e985c482b34f3452560f69430deb2261d1096b",
+        "sha256_in_prefix": "497cb28efabb2e321f9621aa23e985c482b34f3452560f69430deb2261d1096b",
+        "size_in_bytes": 2986
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/shift_jis.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4a0456ad20213ec0d28ed9ddff21ca4abf1f1556d8c2883509942aef95568764",
+        "sha256_in_prefix": "4a0456ad20213ec0d28ed9ddff21ca4abf1f1556d8c2883509942aef95568764",
+        "size_in_bytes": 1404
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/shift_jis_2004.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c7fc7ad8e1bf092e560f35b49f365eb44763f8bcdcf1ee786c21619c0e4230a2",
+        "sha256_in_prefix": "c7fc7ad8e1bf092e560f35b49f365eb44763f8bcdcf1ee786c21619c0e4230a2",
+        "size_in_bytes": 1414
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/shift_jisx0213.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4a3674ab2030815b0b383883d88fa14c80e45840b61ae064767837c000cefa8c",
+        "sha256_in_prefix": "4a3674ab2030815b0b383883d88fa14c80e45840b61ae064767837c000cefa8c",
+        "size_in_bytes": 1414
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/tis_620.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2222ce3a8d56e63037f48b26f29ca0407b3326632773dd1b07d39b8737c7951f",
+        "sha256_in_prefix": "2222ce3a8d56e63037f48b26f29ca0407b3326632773dd1b07d39b8737c7951f",
+        "size_in_bytes": 2496
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/undefined.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "07691d9ef033bc2c4ab750a90555196381db60cbba8ae04bd8ce1d7c00aeae5e",
+        "sha256_in_prefix": "07691d9ef033bc2c4ab750a90555196381db60cbba8ae04bd8ce1d7c00aeae5e",
+        "size_in_bytes": 2080
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/unicode_escape.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7327926b0356bd45ef472b76283abe7faefcc5b1329d40c67d4714ae0f5bca6d",
+        "sha256_in_prefix": "7327926b0356bd45ef472b76283abe7faefcc5b1329d40c67d4714ae0f5bca6d",
+        "size_in_bytes": 1938
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/utf_16.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de4299a7ef9bfcf4d7d643a32ee6993cd829bb73562af4b60f9a377ff1a46fe7",
+        "sha256_in_prefix": "de4299a7ef9bfcf4d7d643a32ee6993cd829bb73562af4b60f9a377ff1a46fe7",
+        "size_in_bytes": 4855
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/utf_16_be.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f04b0998c0419ac3c7eb686bea25932874e91d98524239282e452accc0392519",
+        "sha256_in_prefix": "f04b0998c0419ac3c7eb686bea25932874e91d98524239282e452accc0392519",
+        "size_in_bytes": 1635
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/utf_16_le.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "57344fdd5da669eade0b57023c50d37f904df0f29cb96e1bd098813a6ad6b396",
+        "sha256_in_prefix": "57344fdd5da669eade0b57023c50d37f904df0f29cb96e1bd098813a6ad6b396",
+        "size_in_bytes": 1635
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/utf_32.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "95252123ed278acf9868fbd6a2fde8fe1e08ce22078cb1e45f246c926045806a",
+        "sha256_in_prefix": "95252123ed278acf9868fbd6a2fde8fe1e08ce22078cb1e45f246c926045806a",
+        "size_in_bytes": 4748
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/utf_32_be.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d58b5f31403ce4ea3ae71c386aa37e0976254f8d11d02f92716e0bd17c79c76f",
+        "sha256_in_prefix": "d58b5f31403ce4ea3ae71c386aa37e0976254f8d11d02f92716e0bd17c79c76f",
+        "size_in_bytes": 1528
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/utf_32_le.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e40ad8569152077a4d20a7ce8c427c66a364384ef621d43a3eb7fa0d6bb9d5ba",
+        "sha256_in_prefix": "e40ad8569152077a4d20a7ce8c427c66a364384ef621d43a3eb7fa0d6bb9d5ba",
+        "size_in_bytes": 1528
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/utf_7.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1e0bbc3ded8135c08abdca1f77c1a33b6610e6d2fa10ff9e7c0da5892f1bbc2a",
+        "sha256_in_prefix": "1e0bbc3ded8135c08abdca1f77c1a33b6610e6d2fa10ff9e7c0da5892f1bbc2a",
+        "size_in_bytes": 1556
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/utf_8.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0a3bb13185158c936a2bd93ebf2611db0ff95d29b6f624b890dc7347b5e7560c",
+        "sha256_in_prefix": "0a3bb13185158c936a2bd93ebf2611db0ff95d29b6f624b890dc7347b5e7560c",
+        "size_in_bytes": 1615
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/utf_8_sig.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3997feb9b9245d7fa24037519e2e8da5c449baeded0f91bd6ce2bb175f553f4c",
+        "sha256_in_prefix": "3997feb9b9245d7fa24037519e2e8da5c449baeded0f91bd6ce2bb175f553f4c",
+        "size_in_bytes": 4527
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/uu_codec.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b277829663db4b8ffcd84c9e316d075f881145ece1ca91415a3ce4a68470c5de",
+        "sha256_in_prefix": "b277829663db4b8ffcd84c9e316d075f881145ece1ca91415a3ce4a68470c5de",
+        "size_in_bytes": 3215
+      },
+      {
+        "_path": "Lib/encodings/__pycache__/zlib_codec.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0f46b254b3fe76feefa38e34e10aac292b58dba94564dfbbe778361092e7f2a8",
+        "sha256_in_prefix": "0f46b254b3fe76feefa38e34e10aac292b58dba94564dfbbe778361092e7f2a8",
+        "size_in_bytes": 3063
+      },
+      {
+        "_path": "Lib/encodings/aliases.py",
+        "path_type": "hardlink",
+        "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2",
+        "sha256_in_prefix": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2",
+        "size_in_bytes": 15677
+      },
+      {
+        "_path": "Lib/encodings/ascii.py",
+        "path_type": "hardlink",
+        "sha256": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3",
+        "sha256_in_prefix": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3",
+        "size_in_bytes": 1248
+      },
+      {
+        "_path": "Lib/encodings/base64_codec.py",
+        "path_type": "hardlink",
+        "sha256": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976",
+        "sha256_in_prefix": "cf9ac7a464f541492486241d1b4bf33e37b45c6499275cc4d69c5a8e564e5976",
+        "size_in_bytes": 1533
+      },
+      {
+        "_path": "Lib/encodings/big5.py",
+        "path_type": "hardlink",
+        "sha256": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c",
+        "sha256_in_prefix": "98fac6f86a20dd05da197e2058176ebfd47edee7074c3248f5f48fe0fb672d7c",
+        "size_in_bytes": 1019
+      },
+      {
+        "_path": "Lib/encodings/big5hkscs.py",
+        "path_type": "hardlink",
+        "sha256": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16",
+        "sha256_in_prefix": "21d051a00fb5c6a86ba187e0c50e811d659ce00991fd5f5b408f71ebb2ef0f16",
+        "size_in_bytes": 1039
+      },
+      {
+        "_path": "Lib/encodings/bz2_codec.py",
+        "path_type": "hardlink",
+        "sha256": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab",
+        "sha256_in_prefix": "1181a2a89102a2b1d2b2f1f4473236d5d1ececdd0be8fdaa498a3dbe21a185ab",
+        "size_in_bytes": 2249
+      },
+      {
+        "_path": "Lib/encodings/charmap.py",
+        "path_type": "hardlink",
+        "sha256": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b",
+        "sha256_in_prefix": "1b8b5fdb36ce3becc62a6115ed904a17083949ec8aaef5a80f7078cec232f43b",
+        "size_in_bytes": 2084
+      },
+      {
+        "_path": "Lib/encodings/cp037.py",
+        "path_type": "hardlink",
+        "sha256": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58",
+        "sha256_in_prefix": "fda6ca994d710e4e0c760e0204c29a4273fc0f14ebe3169306d2eb54c9953f58",
+        "size_in_bytes": 13121
+      },
+      {
+        "_path": "Lib/encodings/cp1006.py",
+        "path_type": "hardlink",
+        "sha256": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473",
+        "sha256_in_prefix": "eaded38b427841bdf280e878f1e26da506e743eaa9429075332af60cce429473",
+        "size_in_bytes": 13568
+      },
+      {
+        "_path": "Lib/encodings/cp1026.py",
+        "path_type": "hardlink",
+        "sha256": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9",
+        "sha256_in_prefix": "f5227237dd7ce5005b16a8e4d8342f0d193193c878e3cf35b9305d22b3b1aaf9",
+        "size_in_bytes": 13113
+      },
+      {
+        "_path": "Lib/encodings/cp1125.py",
+        "path_type": "hardlink",
+        "sha256": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470",
+        "sha256_in_prefix": "f84c7d30ce222e6a50cff1a4c9737173411da108cbd2c9bb57c854480103c470",
+        "size_in_bytes": 34597
+      },
+      {
+        "_path": "Lib/encodings/cp1140.py",
+        "path_type": "hardlink",
+        "sha256": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd",
+        "sha256_in_prefix": "3379d78b244aa905ffe1171a968caaf41b9a0154d1ddc76c05a2abaca2b289fd",
+        "size_in_bytes": 13105
+      },
+      {
+        "_path": "Lib/encodings/cp1250.py",
+        "path_type": "hardlink",
+        "sha256": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970",
+        "sha256_in_prefix": "ebcec1adf9167863fb0bab29708c546300c80a77ef07838c9e0437a59e265970",
+        "size_in_bytes": 13686
+      },
+      {
+        "_path": "Lib/encodings/cp1251.py",
+        "path_type": "hardlink",
+        "sha256": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1",
+        "sha256_in_prefix": "d57f8cfa34494c5acb6692ddb31f616ae2dd89a075d2af6d36b0b7ec2ffe7af1",
+        "size_in_bytes": 13361
+      },
+      {
+        "_path": "Lib/encodings/cp1252.py",
+        "path_type": "hardlink",
+        "sha256": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84",
+        "sha256_in_prefix": "19aa5bee667f5fb387924a813aec9fa1dda47769d09e8483a748bdb202be6a84",
+        "size_in_bytes": 13511
+      },
+      {
+        "_path": "Lib/encodings/cp1253.py",
+        "path_type": "hardlink",
+        "sha256": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8",
+        "sha256_in_prefix": "8c27696dcfb6894b378869bc89f113703fbd1e9b13a83934463d5999b055d1e8",
+        "size_in_bytes": 13094
+      },
+      {
+        "_path": "Lib/encodings/cp1254.py",
+        "path_type": "hardlink",
+        "sha256": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d",
+        "sha256_in_prefix": "06517ec2f74f1c6562d0a1a500c48ba43f2e6e9d0c3d28356d747f274f1a4c8d",
+        "size_in_bytes": 13502
+      },
+      {
+        "_path": "Lib/encodings/cp1255.py",
+        "path_type": "hardlink",
+        "sha256": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653",
+        "sha256_in_prefix": "54a1b5087578fa78e5bdd0afa6a9e80e8c5467c1e4226cf6e586cfe7a674a653",
+        "size_in_bytes": 12466
+      },
+      {
+        "_path": "Lib/encodings/cp1256.py",
+        "path_type": "hardlink",
+        "sha256": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133",
+        "sha256_in_prefix": "ad3768ac2fef2a646b3301c20af705f4d4a1544f22fa8a84241bada27ab84133",
+        "size_in_bytes": 12814
+      },
+      {
+        "_path": "Lib/encodings/cp1257.py",
+        "path_type": "hardlink",
+        "sha256": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b",
+        "sha256_in_prefix": "d9149d2925b3f719809ef2297e541461079f15c658af207a3e498be314ab2c6b",
+        "size_in_bytes": 13374
+      },
+      {
+        "_path": "Lib/encodings/cp1258.py",
+        "path_type": "hardlink",
+        "sha256": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630",
+        "sha256_in_prefix": "672e05b51952a82c8dbd5603769195fcedf565e457bb86c0d5bae04955d04630",
+        "size_in_bytes": 13364
+      },
+      {
+        "_path": "Lib/encodings/cp273.py",
+        "path_type": "hardlink",
+        "sha256": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f",
+        "sha256_in_prefix": "6c6aec3b213ea3aebc2c526dd4d121c95d4a25a2fc928a87cd80f8448988185f",
+        "size_in_bytes": 14132
+      },
+      {
+        "_path": "Lib/encodings/cp424.py",
+        "path_type": "hardlink",
+        "sha256": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca",
+        "sha256_in_prefix": "30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca",
+        "size_in_bytes": 12055
+      },
+      {
+        "_path": "Lib/encodings/cp437.py",
+        "path_type": "hardlink",
+        "sha256": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb",
+        "sha256_in_prefix": "5c2a5015cd36cf7f561269f33dec4c323093d3d88b0673969accdabdcb9ce2cb",
+        "size_in_bytes": 34564
+      },
+      {
+        "_path": "Lib/encodings/cp500.py",
+        "path_type": "hardlink",
+        "sha256": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b",
+        "sha256_in_prefix": "630f503f9110d98ea3e1529f2f965ebc275a2f78d3de47f8e9b69d35589d764b",
+        "size_in_bytes": 13121
+      },
+      {
+        "_path": "Lib/encodings/cp720.py",
+        "path_type": "hardlink",
+        "sha256": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0",
+        "sha256_in_prefix": "395496001271b92efe5df07fc0ae7c3410d1dd2bdfebbd3e4d8e806c8166beb0",
+        "size_in_bytes": 13686
+      },
+      {
+        "_path": "Lib/encodings/cp737.py",
+        "path_type": "hardlink",
+        "sha256": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b",
+        "sha256_in_prefix": "be3ca1785a3970ec62310710eaf7de82932181b04d06fe4528f8adaba9fb8c4b",
+        "size_in_bytes": 34681
+      },
+      {
+        "_path": "Lib/encodings/cp775.py",
+        "path_type": "hardlink",
+        "sha256": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb",
+        "sha256_in_prefix": "e0dba85b99329d7f16907e620adada06be5216abcb964406c827b569b2cf1aeb",
+        "size_in_bytes": 34476
+      },
+      {
+        "_path": "Lib/encodings/cp850.py",
+        "path_type": "hardlink",
+        "sha256": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c",
+        "sha256_in_prefix": "257e29f235e2a8790dd68cee45668776648bab809ce8584f893cdd8fd007993c",
+        "size_in_bytes": 34105
+      },
+      {
+        "_path": "Lib/encodings/cp852.py",
+        "path_type": "hardlink",
+        "sha256": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b",
+        "sha256_in_prefix": "cc6faaa9dc4a933127da0aaacd1dc7a44c09266051af56bfe3215ff228636b6b",
+        "size_in_bytes": 35002
+      },
+      {
+        "_path": "Lib/encodings/cp855.py",
+        "path_type": "hardlink",
+        "sha256": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba",
+        "sha256_in_prefix": "7b25c61c9e8c47b218d3fbb801541a2861926ac712843d2113fff90e2074f5ba",
+        "size_in_bytes": 33850
+      },
+      {
+        "_path": "Lib/encodings/cp856.py",
+        "path_type": "hardlink",
+        "sha256": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f",
+        "sha256_in_prefix": "2e52ec5cb1eafa6739b5569b0b98ee89df5f7358b84ccdc8da64e86f017d359f",
+        "size_in_bytes": 12423
+      },
+      {
+        "_path": "Lib/encodings/cp857.py",
+        "path_type": "hardlink",
+        "sha256": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da",
+        "sha256_in_prefix": "8d1b769058bfccdb3c6c70c49a104f5081a2fcc9fad68f7b5eb3e4f67f0b33da",
+        "size_in_bytes": 33908
+      },
+      {
+        "_path": "Lib/encodings/cp858.py",
+        "path_type": "hardlink",
+        "sha256": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b",
+        "sha256_in_prefix": "a24930c4a6ad0ff66dde9a69f2027e4b92c2c9c61dcda2992e940654c606577b",
+        "size_in_bytes": 34015
+      },
+      {
+        "_path": "Lib/encodings/cp860.py",
+        "path_type": "hardlink",
+        "sha256": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a",
+        "sha256_in_prefix": "2dfae7e31d3d9aa3013cff44a4d7ad842f257ac63765a9998436701b629cd86a",
+        "size_in_bytes": 34681
+      },
+      {
+        "_path": "Lib/encodings/cp861.py",
+        "path_type": "hardlink",
+        "sha256": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e",
+        "sha256_in_prefix": "701930d77a2177497586e99bc3fe60f2d4beffb645608f167c76874a72ff405e",
+        "size_in_bytes": 34633
+      },
+      {
+        "_path": "Lib/encodings/cp862.py",
+        "path_type": "hardlink",
+        "sha256": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d",
+        "sha256_in_prefix": "15a2844b6ed9544c6400cf7299b42d0c2bef93c9bee70a9e89f66b8610ad6d6d",
+        "size_in_bytes": 33370
+      },
+      {
+        "_path": "Lib/encodings/cp863.py",
+        "path_type": "hardlink",
+        "sha256": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2",
+        "sha256_in_prefix": "a3d57f61fce1b98fc81ea8e4ebebaf402fae40bbcdd35d4b8297b9bb49a79aa2",
+        "size_in_bytes": 34252
+      },
+      {
+        "_path": "Lib/encodings/cp864.py",
+        "path_type": "hardlink",
+        "sha256": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08",
+        "sha256_in_prefix": "15ad8f1fdfdd842c7522241372e7eddda7df687e815692a89157c5f256f21a08",
+        "size_in_bytes": 33663
+      },
+      {
+        "_path": "Lib/encodings/cp865.py",
+        "path_type": "hardlink",
+        "sha256": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907",
+        "sha256_in_prefix": "bdbaded987242ed2a8de7133ec2f61ddcc1c2e9de27816ab7cd0a4c678a3a907",
+        "size_in_bytes": 34618
+      },
+      {
+        "_path": "Lib/encodings/cp866.py",
+        "path_type": "hardlink",
+        "sha256": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13",
+        "sha256_in_prefix": "9efcc8e85bbd1687272a0991f6d0429a4c06679db2d114b2ac95db27a70f9d13",
+        "size_in_bytes": 34396
+      },
+      {
+        "_path": "Lib/encodings/cp869.py",
+        "path_type": "hardlink",
+        "sha256": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d",
+        "sha256_in_prefix": "52582d9fb769b24eac7154f18d7dae856588297d6da98f37fb5efd8da883826d",
+        "size_in_bytes": 32965
+      },
+      {
+        "_path": "Lib/encodings/cp874.py",
+        "path_type": "hardlink",
+        "sha256": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f",
+        "sha256_in_prefix": "fe4752fa2e65741e08a563a31ff914fe71068942ce9c6f4070b1dfd7b25e5e7f",
+        "size_in_bytes": 12595
+      },
+      {
+        "_path": "Lib/encodings/cp875.py",
+        "path_type": "hardlink",
+        "sha256": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257",
+        "sha256_in_prefix": "2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257",
+        "size_in_bytes": 12854
+      },
+      {
+        "_path": "Lib/encodings/cp932.py",
+        "path_type": "hardlink",
+        "sha256": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4",
+        "sha256_in_prefix": "99748e28113d2d49f5d666b49b78accd2c6e10a7852f7dd6dece9b5b71aa83c4",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/encodings/cp949.py",
+        "path_type": "hardlink",
+        "sha256": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962",
+        "sha256_in_prefix": "950a7d29467ce0590b4a1137830d43d88d8f20e4035dcaaa8b2a5c3c3f1de962",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/encodings/cp950.py",
+        "path_type": "hardlink",
+        "sha256": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6",
+        "sha256_in_prefix": "27811178b450731fc955b1247656a605d04e5ee98e0d585e4596b94b703a27f6",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/encodings/euc_jis_2004.py",
+        "path_type": "hardlink",
+        "sha256": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d",
+        "sha256_in_prefix": "9fa426cd9f17629f6320700ed18baa94839304cf1bcabbee7edb501747dc055d",
+        "size_in_bytes": 1051
+      },
+      {
+        "_path": "Lib/encodings/euc_jisx0213.py",
+        "path_type": "hardlink",
+        "sha256": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b",
+        "sha256_in_prefix": "e28315910da20218dae8b7d5becd81de1e283dfd8b0415a4980d67065de73a0b",
+        "size_in_bytes": 1051
+      },
+      {
+        "_path": "Lib/encodings/euc_jp.py",
+        "path_type": "hardlink",
+        "sha256": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc",
+        "sha256_in_prefix": "b453a439787b0efa031e43416a7d852a6be705c985e1200693eb96d87ea79cdc",
+        "size_in_bytes": 1027
+      },
+      {
+        "_path": "Lib/encodings/euc_kr.py",
+        "path_type": "hardlink",
+        "sha256": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6",
+        "sha256_in_prefix": "633a1a5504bfad04b1ec9c96d44d4ebb3bb99066a218318e7d67d866e20887a6",
+        "size_in_bytes": 1027
+      },
+      {
+        "_path": "Lib/encodings/gb18030.py",
+        "path_type": "hardlink",
+        "sha256": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521",
+        "sha256_in_prefix": "6c10b4dc49bc63724e539137ede6936304fcca1c97c28d16d89f381e10849521",
+        "size_in_bytes": 1031
+      },
+      {
+        "_path": "Lib/encodings/gb2312.py",
+        "path_type": "hardlink",
+        "sha256": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b",
+        "sha256_in_prefix": "3d2d567d8d079b78f3f3b566ed52ad2f38af61bf832b7dc28858b0039a032d6b",
+        "size_in_bytes": 1027
+      },
+      {
+        "_path": "Lib/encodings/gbk.py",
+        "path_type": "hardlink",
+        "sha256": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b",
+        "sha256_in_prefix": "eff9b8cbc9ad2ef2e10e96afa83d3db1f775ea044aed275b7a35574ae0d8645b",
+        "size_in_bytes": 1015
+      },
+      {
+        "_path": "Lib/encodings/hex_codec.py",
+        "path_type": "hardlink",
+        "sha256": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047",
+        "sha256_in_prefix": "fc5f0a31b59efe990b86efb98936769f33dd91d912ce55b49a5a4cfc516cd047",
+        "size_in_bytes": 1508
+      },
+      {
+        "_path": "Lib/encodings/hp_roman8.py",
+        "path_type": "hardlink",
+        "sha256": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b",
+        "sha256_in_prefix": "c43cce763d12e8f71a63dbc16641bd87147eaf5f9d9054ea856864b216b2735b",
+        "size_in_bytes": 13475
+      },
+      {
+        "_path": "Lib/encodings/hz.py",
+        "path_type": "hardlink",
+        "sha256": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a",
+        "sha256_in_prefix": "025a9531e3046e52d3e039c0be04f9a5a74651d7683a13c7c7ebd4c7dfb5996a",
+        "size_in_bytes": 1011
+      },
+      {
+        "_path": "Lib/encodings/idna.py",
+        "path_type": "hardlink",
+        "sha256": "4fc5a79f53d60fd0576f94dfe8aa7677357d9ad95315ea220ba523f53c89229b",
+        "sha256_in_prefix": "4fc5a79f53d60fd0576f94dfe8aa7677357d9ad95315ea220ba523f53c89229b",
+        "size_in_bytes": 9098
+      },
+      {
+        "_path": "Lib/encodings/iso2022_jp.py",
+        "path_type": "hardlink",
+        "sha256": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77",
+        "sha256_in_prefix": "461a0e7f72eccb8b29f351c4e7926cfbda58e0edd6d0770bd82e0b36c5febe77",
+        "size_in_bytes": 1053
+      },
+      {
+        "_path": "Lib/encodings/iso2022_jp_1.py",
+        "path_type": "hardlink",
+        "sha256": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd",
+        "sha256_in_prefix": "63bacad13a979a5519fcaa4f1e1e07b2c7415005167fac3a689408c7d886fabd",
+        "size_in_bytes": 1061
+      },
+      {
+        "_path": "Lib/encodings/iso2022_jp_2.py",
+        "path_type": "hardlink",
+        "sha256": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f",
+        "sha256_in_prefix": "5d4248181548b0fc89a9f5ee9cf52ebecb235708ba87d47896ad14130884ef9f",
+        "size_in_bytes": 1061
+      },
+      {
+        "_path": "Lib/encodings/iso2022_jp_2004.py",
+        "path_type": "hardlink",
+        "sha256": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164",
+        "sha256_in_prefix": "b4d1468bcd608b46f38cb0c6ef115510dcf9aa0f71e590792f407efc6e165164",
+        "size_in_bytes": 1073
+      },
+      {
+        "_path": "Lib/encodings/iso2022_jp_3.py",
+        "path_type": "hardlink",
+        "sha256": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac",
+        "sha256_in_prefix": "3aceaa5661909de14e2861d864443b8472460ce39b99cce5c6965346d47aa5ac",
+        "size_in_bytes": 1061
+      },
+      {
+        "_path": "Lib/encodings/iso2022_jp_ext.py",
+        "path_type": "hardlink",
+        "sha256": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c",
+        "sha256_in_prefix": "f4c9ed8f3031995faa224bcb10153d2b6144944477d1f27d1a6cc4a879fac34c",
+        "size_in_bytes": 1069
+      },
+      {
+        "_path": "Lib/encodings/iso2022_kr.py",
+        "path_type": "hardlink",
+        "sha256": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4",
+        "sha256_in_prefix": "1c86362e17944f0bcf68db02f4995bdeea605867795fff7ab4079073f96705e4",
+        "size_in_bytes": 1053
+      },
+      {
+        "_path": "Lib/encodings/iso8859_1.py",
+        "path_type": "hardlink",
+        "sha256": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d",
+        "sha256_in_prefix": "b5cebd515e057d670bf54e10b8a6f162ef3daa7f21b146aee3249160caf3c32d",
+        "size_in_bytes": 13176
+      },
+      {
+        "_path": "Lib/encodings/iso8859_10.py",
+        "path_type": "hardlink",
+        "sha256": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b",
+        "sha256_in_prefix": "54c886b41819ebb7f4fb34b8dbae1c45f4fc0864f019ecd772676ccfac5fae7b",
+        "size_in_bytes": 13589
+      },
+      {
+        "_path": "Lib/encodings/iso8859_11.py",
+        "path_type": "hardlink",
+        "sha256": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef",
+        "sha256_in_prefix": "ed5a964470a241b4da7a6cfb718e4149d09644933af38f0497602baab6e563ef",
+        "size_in_bytes": 12335
+      },
+      {
+        "_path": "Lib/encodings/iso8859_13.py",
+        "path_type": "hardlink",
+        "sha256": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206",
+        "sha256_in_prefix": "7312237e8e5d201d920b4130f057cfdf1b0be9baafaa246826e6d93204fcc206",
+        "size_in_bytes": 13271
+      },
+      {
+        "_path": "Lib/encodings/iso8859_14.py",
+        "path_type": "hardlink",
+        "sha256": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343",
+        "sha256_in_prefix": "82778b995a0ee87c5f1180fcc52900359eee15bd9a6e3a0e25f0d963e0b2a343",
+        "size_in_bytes": 13652
+      },
+      {
+        "_path": "Lib/encodings/iso8859_15.py",
+        "path_type": "hardlink",
+        "sha256": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02",
+        "sha256_in_prefix": "01976a81811873dc9a0c79db9fc00d1c30103487f3c6bc3a6d81b4043cd48e02",
+        "size_in_bytes": 13212
+      },
+      {
+        "_path": "Lib/encodings/iso8859_16.py",
+        "path_type": "hardlink",
+        "sha256": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66",
+        "sha256_in_prefix": "b5ac8f5a5d8f84c0f903b2b7c342184758d590d8bcf810d561f942fe5b372d66",
+        "size_in_bytes": 13557
+      },
+      {
+        "_path": "Lib/encodings/iso8859_2.py",
+        "path_type": "hardlink",
+        "sha256": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc",
+        "sha256_in_prefix": "2b57cab6111cae9021505e3ae1b2adbbfc344ec48165fda322f6b069fbb18adc",
+        "size_in_bytes": 13404
+      },
+      {
+        "_path": "Lib/encodings/iso8859_3.py",
+        "path_type": "hardlink",
+        "sha256": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242",
+        "sha256_in_prefix": "4ffdf89004bf0c5230caa7079f7ca3142fc112f8b923ddb2c7358369d2d3c242",
+        "size_in_bytes": 13089
+      },
+      {
+        "_path": "Lib/encodings/iso8859_4.py",
+        "path_type": "hardlink",
+        "sha256": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5",
+        "sha256_in_prefix": "87bd130daa0eaef3e4cb465e10cffb2bcd194ff74097e0c186b4b8eb7be41ac5",
+        "size_in_bytes": 13376
+      },
+      {
+        "_path": "Lib/encodings/iso8859_5.py",
+        "path_type": "hardlink",
+        "sha256": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30",
+        "sha256_in_prefix": "9961d96cc7b9fdf011ebcaaeaeca7b50b8670fadbd7b75fde66192f8c1f68f30",
+        "size_in_bytes": 13015
+      },
+      {
+        "_path": "Lib/encodings/iso8859_6.py",
+        "path_type": "hardlink",
+        "sha256": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6",
+        "sha256_in_prefix": "4840e68014346517680f593ca22f67133c39ba7e46f34b9be62c980a728448c6",
+        "size_in_bytes": 10833
+      },
+      {
+        "_path": "Lib/encodings/iso8859_7.py",
+        "path_type": "hardlink",
+        "sha256": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4",
+        "sha256_in_prefix": "b352eca3b819488f64fb3338fd93f39c1e30f32bb13f2f9c577925e58f2960e4",
+        "size_in_bytes": 12844
+      },
+      {
+        "_path": "Lib/encodings/iso8859_8.py",
+        "path_type": "hardlink",
+        "sha256": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e",
+        "sha256_in_prefix": "4cf9e8a8bbe04accb1c1a80853efb19ae0772d18f81e270adefc1b2386cb368e",
+        "size_in_bytes": 11036
+      },
+      {
+        "_path": "Lib/encodings/iso8859_9.py",
+        "path_type": "hardlink",
+        "sha256": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359",
+        "sha256_in_prefix": "84d9b15263e81685f7513c5ab45caf80b2f73c301c68e659f7162c1b1882d359",
+        "size_in_bytes": 13156
+      },
+      {
+        "_path": "Lib/encodings/johab.py",
+        "path_type": "hardlink",
+        "sha256": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb",
+        "sha256_in_prefix": "9586615917afd3d848c1c4328656603b2834af6115f2aec932fccc935e1a60fb",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/encodings/koi8_r.py",
+        "path_type": "hardlink",
+        "sha256": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d",
+        "sha256_in_prefix": "4d4e353aee8039bb71e2145a6e68fe1e6833a1b4250b70ee0ac5ec70bbb8c51d",
+        "size_in_bytes": 13779
+      },
+      {
+        "_path": "Lib/encodings/koi8_t.py",
+        "path_type": "hardlink",
+        "sha256": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1",
+        "sha256_in_prefix": "9c9043814abdbe7dc39ff98f3857d5d110a84c978ad2304158d810a4e9eacef1",
+        "size_in_bytes": 13193
+      },
+      {
+        "_path": "Lib/encodings/koi8_u.py",
+        "path_type": "hardlink",
+        "sha256": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7",
+        "sha256_in_prefix": "d449f9858e357fa8c2edbd4b9fe739337e9f201cac3ded20f99bfcecd4970ff7",
+        "size_in_bytes": 13762
+      },
+      {
+        "_path": "Lib/encodings/kz1048.py",
+        "path_type": "hardlink",
+        "sha256": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc",
+        "sha256_in_prefix": "76beb30e98a911f72f97609a2373782573c17c88a5fb3537db338aa382979ffc",
+        "size_in_bytes": 13723
+      },
+      {
+        "_path": "Lib/encodings/latin_1.py",
+        "path_type": "hardlink",
+        "sha256": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c",
+        "sha256_in_prefix": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c",
+        "size_in_bytes": 1264
+      },
+      {
+        "_path": "Lib/encodings/mac_arabic.py",
+        "path_type": "hardlink",
+        "sha256": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777",
+        "sha256_in_prefix": "5eafd9a3136abfbd8ed52df9c90203c7a283e7429ed60502a87a02511e0fb777",
+        "size_in_bytes": 36467
+      },
+      {
+        "_path": "Lib/encodings/mac_croatian.py",
+        "path_type": "hardlink",
+        "sha256": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953",
+        "sha256_in_prefix": "a880cd05c82a8d11a29c65ee86a396def3344465dd71441b0bb4a73826024953",
+        "size_in_bytes": 13633
+      },
+      {
+        "_path": "Lib/encodings/mac_cyrillic.py",
+        "path_type": "hardlink",
+        "sha256": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd",
+        "sha256_in_prefix": "83616786a1c6308b03a0dc82536908d24d0974b2248d67393d613fe558cea4bd",
+        "size_in_bytes": 13454
+      },
+      {
+        "_path": "Lib/encodings/mac_farsi.py",
+        "path_type": "hardlink",
+        "sha256": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624",
+        "sha256_in_prefix": "f5763c38fb4ab0423fafe2fdca34d6f9932ac7f1a74c0cd8109d60234c7dc624",
+        "size_in_bytes": 15170
+      },
+      {
+        "_path": "Lib/encodings/mac_greek.py",
+        "path_type": "hardlink",
+        "sha256": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e",
+        "sha256_in_prefix": "63016a323ddf98cb3aa9cfa78f3bab4768bedbfe9a5262a36a5aecb13d291f6e",
+        "size_in_bytes": 13721
+      },
+      {
+        "_path": "Lib/encodings/mac_iceland.py",
+        "path_type": "hardlink",
+        "sha256": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37",
+        "sha256_in_prefix": "753cc1ac635caa7e1b4630fbcebef8db8db332c098154a5b11f652912bf64f37",
+        "size_in_bytes": 13498
+      },
+      {
+        "_path": "Lib/encodings/mac_latin2.py",
+        "path_type": "hardlink",
+        "sha256": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50",
+        "sha256_in_prefix": "31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50",
+        "size_in_bytes": 14118
+      },
+      {
+        "_path": "Lib/encodings/mac_roman.py",
+        "path_type": "hardlink",
+        "sha256": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22",
+        "sha256_in_prefix": "230367d96aef8e8d7f185b4acfb84923714f39ddbcbf9cf38a06bf6f5d621c22",
+        "size_in_bytes": 13480
+      },
+      {
+        "_path": "Lib/encodings/mac_romanian.py",
+        "path_type": "hardlink",
+        "sha256": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee",
+        "sha256_in_prefix": "49630cf035c19e896a123ed6e5fee18b5e485123daf2f15da38bf727ff387bee",
+        "size_in_bytes": 13661
+      },
+      {
+        "_path": "Lib/encodings/mac_turkish.py",
+        "path_type": "hardlink",
+        "sha256": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b",
+        "sha256_in_prefix": "99758a5cad2825cb3be3fa5d031e0821e4eba910a46f417fd890207b9b6be77b",
+        "size_in_bytes": 13513
+      },
+      {
+        "_path": "Lib/encodings/mbcs.py",
+        "path_type": "hardlink",
+        "sha256": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864",
+        "sha256_in_prefix": "f6ed445ed537c9f856d8defe8b56505727737d0dc9348d0a877abedab4bdd864",
+        "size_in_bytes": 1211
+      },
+      {
+        "_path": "Lib/encodings/oem.py",
+        "path_type": "hardlink",
+        "sha256": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f",
+        "sha256_in_prefix": "481656d3a35f792d0e5109e3f821e6dbfcf097163a19b0cdfcbff3b3db99292f",
+        "size_in_bytes": 1019
+      },
+      {
+        "_path": "Lib/encodings/palmos.py",
+        "path_type": "hardlink",
+        "sha256": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8",
+        "sha256_in_prefix": "eccf7418adefcc2a59e9a07fc4e34363bd62f7e878d48c8a02730a8ed1c584c8",
+        "size_in_bytes": 13519
+      },
+      {
+        "_path": "Lib/encodings/ptcp154.py",
+        "path_type": "hardlink",
+        "sha256": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d",
+        "sha256_in_prefix": "0eabcb2c287d335e86b71b0abe5718bd6ddc9aaee234f0f0f2363845d2926d8d",
+        "size_in_bytes": 14015
+      },
+      {
+        "_path": "Lib/encodings/punycode.py",
+        "path_type": "hardlink",
+        "sha256": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c",
+        "sha256_in_prefix": "34edc8fb1c50e4d1cbaa1e008bb491cd7c12116c316e51974f333fe7b628eb7c",
+        "size_in_bytes": 6883
+      },
+      {
+        "_path": "Lib/encodings/quopri_codec.py",
+        "path_type": "hardlink",
+        "sha256": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64",
+        "sha256_in_prefix": "502a213c34c05a94ed063ee03f47680bd6efbb35036e06fb4dc809bf398cfa64",
+        "size_in_bytes": 1525
+      },
+      {
+        "_path": "Lib/encodings/raw_unicode_escape.py",
+        "path_type": "hardlink",
+        "sha256": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a",
+        "sha256_in_prefix": "fa6328486b8f5a5cbd10e377e80adb8cf94acbbe19c38b4e1bf708d831a80a3a",
+        "size_in_bytes": 1332
+      },
+      {
+        "_path": "Lib/encodings/rot_13.py",
+        "path_type": "hardlink",
+        "sha256": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4",
+        "sha256_in_prefix": "14767f475acdc0bf48e6272280dd15b80efaecafb93c06be21136f83dd1ee7e4",
+        "size_in_bytes": 2448
+      },
+      {
+        "_path": "Lib/encodings/shift_jis.py",
+        "path_type": "hardlink",
+        "sha256": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966",
+        "sha256_in_prefix": "ad4ac50ebf58294304e412cc0f1b12980988dd6edc414e4110029c0a1abbe966",
+        "size_in_bytes": 1039
+      },
+      {
+        "_path": "Lib/encodings/shift_jis_2004.py",
+        "path_type": "hardlink",
+        "sha256": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99",
+        "sha256_in_prefix": "d21c5930f21063ea78fea3b0f76dfb8fd92858d2a4a200064a52126a43dd1a99",
+        "size_in_bytes": 1059
+      },
+      {
+        "_path": "Lib/encodings/shift_jisx0213.py",
+        "path_type": "hardlink",
+        "sha256": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e",
+        "sha256_in_prefix": "2c8d0b93bb36edf31c1236b1b4d1c0008553868bd2fc9137570115b96b834f2e",
+        "size_in_bytes": 1059
+      },
+      {
+        "_path": "Lib/encodings/tis_620.py",
+        "path_type": "hardlink",
+        "sha256": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902",
+        "sha256_in_prefix": "647c4719e2c1a7375105e15a89b377c66f6b699977dcabbb71d923a4607b7902",
+        "size_in_bytes": 12300
+      },
+      {
+        "_path": "Lib/encodings/undefined.py",
+        "path_type": "hardlink",
+        "sha256": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64",
+        "sha256_in_prefix": "85bba5c5e1007cd8c1ade5c0214bcc825396d2bbd02054e62a9f162104748b64",
+        "size_in_bytes": 1299
+      },
+      {
+        "_path": "Lib/encodings/unicode_escape.py",
+        "path_type": "hardlink",
+        "sha256": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d",
+        "sha256_in_prefix": "507e7ca8f18df639fd823d7cc23ce4028a3550ceefdfa40b3c76f81d1a94531d",
+        "size_in_bytes": 1304
+      },
+      {
+        "_path": "Lib/encodings/utf_16.py",
+        "path_type": "hardlink",
+        "sha256": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58",
+        "sha256_in_prefix": "6c36257f7b8d214473560d195e71bccef0c69a53e1e52d2800b7a7890aad7e58",
+        "size_in_bytes": 5236
+      },
+      {
+        "_path": "Lib/encodings/utf_16_be.py",
+        "path_type": "hardlink",
+        "sha256": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f",
+        "sha256_in_prefix": "3357196f3fa52433326a6626880e34964e00c5570aee50e9a0a0a7c6d86f6e4f",
+        "size_in_bytes": 1037
+      },
+      {
+        "_path": "Lib/encodings/utf_16_le.py",
+        "path_type": "hardlink",
+        "sha256": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80",
+        "sha256_in_prefix": "3aedaf3eb49769282daef1eaedfd4fa1c31fe5eebeff67fe2307c89dc2e2fd80",
+        "size_in_bytes": 1037
+      },
+      {
+        "_path": "Lib/encodings/utf_32.py",
+        "path_type": "hardlink",
+        "sha256": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2",
+        "sha256_in_prefix": "2072eece5f6026ad2d3549ab193a9e38894ea15ca9d5b3cd408fd6b116acc0c2",
+        "size_in_bytes": 5129
+      },
+      {
+        "_path": "Lib/encodings/utf_32_be.py",
+        "path_type": "hardlink",
+        "sha256": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd",
+        "sha256_in_prefix": "cbba20e1f6d0879c7c4293446c371a9f79e7c90bf3c78a77a9b8fc72b18915dd",
+        "size_in_bytes": 930
+      },
+      {
+        "_path": "Lib/encodings/utf_32_le.py",
+        "path_type": "hardlink",
+        "sha256": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b",
+        "sha256_in_prefix": "9134b91047d85b442898d59effe23e7e0cf4167ca341ae31119a731dbf880a7b",
+        "size_in_bytes": 930
+      },
+      {
+        "_path": "Lib/encodings/utf_7.py",
+        "path_type": "hardlink",
+        "sha256": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d",
+        "sha256_in_prefix": "9ff32314f4f1fa074f206bbf7fdb851504e5313128636d73b4bf75b886e4a87d",
+        "size_in_bytes": 946
+      },
+      {
+        "_path": "Lib/encodings/utf_8.py",
+        "path_type": "hardlink",
+        "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d",
+        "sha256_in_prefix": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d",
+        "size_in_bytes": 1005
+      },
+      {
+        "_path": "Lib/encodings/utf_8_sig.py",
+        "path_type": "hardlink",
+        "sha256": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d",
+        "sha256_in_prefix": "1ef3da8d8aa08149e7f274dc64dbfce2155da812e5258ca8e8f832428d3b5c2d",
+        "size_in_bytes": 4133
+      },
+      {
+        "_path": "Lib/encodings/uu_codec.py",
+        "path_type": "hardlink",
+        "sha256": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3",
+        "sha256_in_prefix": "45ba92000718abf85f158563c755205e100356ce1b4ab9444b4d0a3d21f061a3",
+        "size_in_bytes": 2851
+      },
+      {
+        "_path": "Lib/encodings/zlib_codec.py",
+        "path_type": "hardlink",
+        "sha256": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759",
+        "sha256_in_prefix": "6ef01e8d3a5fe1cc52f7b5ae008df12f1dbce7304111bf8d4758f1bfc0115759",
+        "size_in_bytes": 2204
+      },
+      {
+        "_path": "Lib/ensurepip/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "70b7b7401d3f62892c8434b295282b772bb6a023a3de706a45a73237f0f38e24",
+        "sha256_in_prefix": "70b7b7401d3f62892c8434b295282b772bb6a023a3de706a45a73237f0f38e24",
+        "size_in_bytes": 6963
+      },
+      {
+        "_path": "Lib/ensurepip/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7",
+        "sha256_in_prefix": "ee735f518d0fc4dfec81f7aa3da1e052372ed4202c0da4eddd2587840beaecd7",
+        "size_in_bytes": 88
+      },
+      {
+        "_path": "Lib/ensurepip/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "013003d53848ee733a0f9a233a9a3e16152dbe1c54958da8f437e0791d9ef510",
+        "sha256_in_prefix": "013003d53848ee733a0f9a233a9a3e16152dbe1c54958da8f437e0791d9ef510",
+        "size_in_bytes": 5237
+      },
+      {
+        "_path": "Lib/ensurepip/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "91e8460f94855bb2425602762903e620420a6154c254b0e3b776c83980f74b39",
+        "sha256_in_prefix": "91e8460f94855bb2425602762903e620420a6154c254b0e3b776c83980f74b39",
+        "size_in_bytes": 211
+      },
+      {
+        "_path": "Lib/ensurepip/__pycache__/_uninstall.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3e8cfdfc10d8b678d2713998dcbe3aac46879e9b0b703906847edbf098ba09a2",
+        "sha256_in_prefix": "3e8cfdfc10d8b678d2713998dcbe3aac46879e9b0b703906847edbf098ba09a2",
+        "size_in_bytes": 917
+      },
+      {
+        "_path": "Lib/ensurepip/_bundled/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/ensurepip/_bundled/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd5ea84bba3e42ac7f645fb35c131251c70fee5b497f7c95e1a75df6d002f802",
+        "sha256_in_prefix": "dd5ea84bba3e42ac7f645fb35c131251c70fee5b497f7c95e1a75df6d002f802",
+        "size_in_bytes": 125
+      },
+      {
+        "_path": "Lib/ensurepip/_bundled/pip-23.0.1-py3-none-any.whl",
+        "path_type": "hardlink",
+        "sha256": "236bcb61156d76c4b8a05821b988c7b8c35bf0da28a4b614e8d6ab5212c25c6f",
+        "sha256_in_prefix": "236bcb61156d76c4b8a05821b988c7b8c35bf0da28a4b614e8d6ab5212c25c6f",
+        "size_in_bytes": 2055563
+      },
+      {
+        "_path": "Lib/ensurepip/_bundled/setuptools-58.1.0-py3-none-any.whl",
+        "path_type": "hardlink",
+        "sha256": "7324fd4b66efa05cdfc9c89174573a4410acc7848f318cc0565c7fb659dfdc81",
+        "sha256_in_prefix": "7324fd4b66efa05cdfc9c89174573a4410acc7848f318cc0565c7fb659dfdc81",
+        "size_in_bytes": 816725
+      },
+      {
+        "_path": "Lib/ensurepip/_uninstall.py",
+        "path_type": "hardlink",
+        "sha256": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2",
+        "sha256_in_prefix": "3a6e95d01c45e2e47c05df3c81073b895c97c1eb0e5b90ab175d6d9263fc81f2",
+        "size_in_bytes": 808
+      },
+      {
+        "_path": "Lib/enum.py",
+        "path_type": "hardlink",
+        "sha256": "1fbc8192d68b50b55169e391ef02ade61be803e61665ca65de1c43051d6b7b10",
+        "sha256_in_prefix": "1fbc8192d68b50b55169e391ef02ade61be803e61665ca65de1c43051d6b7b10",
+        "size_in_bytes": 39440
+      },
+      {
+        "_path": "Lib/filecmp.py",
+        "path_type": "hardlink",
+        "sha256": "f9d9e6d259499a5cff38d3cf76040cc34d9f44f886cafc9e16c5cf86c014a775",
+        "sha256_in_prefix": "f9d9e6d259499a5cff38d3cf76040cc34d9f44f886cafc9e16c5cf86c014a775",
+        "size_in_bytes": 10024
+      },
+      {
+        "_path": "Lib/fileinput.py",
+        "path_type": "hardlink",
+        "sha256": "2a3e59fb3782b87de330aad0239152f6169b5fc555d0caea7de2b71990398b12",
+        "sha256_in_prefix": "2a3e59fb3782b87de330aad0239152f6169b5fc555d0caea7de2b71990398b12",
+        "size_in_bytes": 14791
+      },
+      {
+        "_path": "Lib/fnmatch.py",
+        "path_type": "hardlink",
+        "sha256": "10aac42dbd125cb1bf952c9528e43511671d5756616c0f75f6a8f527ac936fc7",
+        "sha256_in_prefix": "10aac42dbd125cb1bf952c9528e43511671d5756616c0f75f6a8f527ac936fc7",
+        "size_in_bytes": 6004
+      },
+      {
+        "_path": "Lib/formatter.py",
+        "path_type": "hardlink",
+        "sha256": "46f7d6271031b4716badb318ca47e29b99447cad7770e3922ba48091b9c898f8",
+        "sha256_in_prefix": "46f7d6271031b4716badb318ca47e29b99447cad7770e3922ba48091b9c898f8",
+        "size_in_bytes": 15143
+      },
+      {
+        "_path": "Lib/fractions.py",
+        "path_type": "hardlink",
+        "sha256": "92e95df7e7b3743c4bc836bbaaf2ec49d539fe9c44148c6e40fb9d9bd3bd0a07",
+        "sha256_in_prefix": "92e95df7e7b3743c4bc836bbaaf2ec49d539fe9c44148c6e40fb9d9bd3bd0a07",
+        "size_in_bytes": 24323
+      },
+      {
+        "_path": "Lib/ftplib.py",
+        "path_type": "hardlink",
+        "sha256": "672300f448249dfd7825369e47111c37b8aa5355ef0a10df3226bd5f849e538e",
+        "sha256_in_prefix": "672300f448249dfd7825369e47111c37b8aa5355ef0a10df3226bd5f849e538e",
+        "size_in_bytes": 35496
+      },
+      {
+        "_path": "Lib/functools.py",
+        "path_type": "hardlink",
+        "sha256": "300563b2de2edbae9b64f8c10c0f267be4f8c97a1524b5e81e99c242e17929b5",
+        "sha256_in_prefix": "300563b2de2edbae9b64f8c10c0f267be4f8c97a1524b5e81e99c242e17929b5",
+        "size_in_bytes": 38881
+      },
+      {
+        "_path": "Lib/genericpath.py",
+        "path_type": "hardlink",
+        "sha256": "9d58ad64056a89f12258a62596c2073cd9e52b459dde152f710edc0cffcd865b",
+        "sha256_in_prefix": "9d58ad64056a89f12258a62596c2073cd9e52b459dde152f710edc0cffcd865b",
+        "size_in_bytes": 4975
+      },
+      {
+        "_path": "Lib/getopt.py",
+        "path_type": "hardlink",
+        "sha256": "efafb88c7c978e96bd6c232b7fa10bf50cef5e7fb0fb7dc8e5bce44e19f8c92f",
+        "sha256_in_prefix": "efafb88c7c978e96bd6c232b7fa10bf50cef5e7fb0fb7dc8e5bce44e19f8c92f",
+        "size_in_bytes": 7489
+      },
+      {
+        "_path": "Lib/getpass.py",
+        "path_type": "hardlink",
+        "sha256": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a",
+        "sha256_in_prefix": "e74fd445337ff503223dd8aa4bdd7d04917067d00c796a10bedb7a1381a4960a",
+        "size_in_bytes": 5990
+      },
+      {
+        "_path": "Lib/gettext.py",
+        "path_type": "hardlink",
+        "sha256": "46c4d4e2e72bcd572e64bfbce15975d8054a65af167664c6da193773c38dd1ae",
+        "sha256_in_prefix": "46c4d4e2e72bcd572e64bfbce15975d8054a65af167664c6da193773c38dd1ae",
+        "size_in_bytes": 27266
+      },
+      {
+        "_path": "Lib/glob.py",
+        "path_type": "hardlink",
+        "sha256": "59b27cd35c7b7fb4c573a23f0bb8dcf16b286cd4b03a9138f32aa3e3f6b83a36",
+        "sha256_in_prefix": "59b27cd35c7b7fb4c573a23f0bb8dcf16b286cd4b03a9138f32aa3e3f6b83a36",
+        "size_in_bytes": 5823
+      },
+      {
+        "_path": "Lib/graphlib.py",
+        "path_type": "hardlink",
+        "sha256": "c903f32178ae8205b73caca478c6505318dcc84b006acd6e9ca7da6479a1e05f",
+        "sha256_in_prefix": "c903f32178ae8205b73caca478c6505318dcc84b006acd6e9ca7da6479a1e05f",
+        "size_in_bytes": 9573
+      },
+      {
+        "_path": "Lib/gzip.py",
+        "path_type": "hardlink",
+        "sha256": "e1287cead7a16d31bacb1498e3847467f672056d5b0b8d5fa7f2ba4e0c5d3cba",
+        "sha256_in_prefix": "e1287cead7a16d31bacb1498e3847467f672056d5b0b8d5fa7f2ba4e0c5d3cba",
+        "size_in_bytes": 21772
+      },
+      {
+        "_path": "Lib/hashlib.py",
+        "path_type": "hardlink",
+        "sha256": "a25e6f24d6ae5b5205844e2717f3d6dbeda005c1afeaf4d450b4f2c363a3d34a",
+        "sha256_in_prefix": "a25e6f24d6ae5b5205844e2717f3d6dbeda005c1afeaf4d450b4f2c363a3d34a",
+        "size_in_bytes": 10010
+      },
+      {
+        "_path": "Lib/heapq.py",
+        "path_type": "hardlink",
+        "sha256": "0351667ed3afd3310ebd353526824d6f6f34d641ef0a785552c6893b7f95fdf3",
+        "sha256_in_prefix": "0351667ed3afd3310ebd353526824d6f6f34d641ef0a785552c6893b7f95fdf3",
+        "size_in_bytes": 22877
+      },
+      {
+        "_path": "Lib/hmac.py",
+        "path_type": "hardlink",
+        "sha256": "fbac1d9d715d97c3dbed0dcb541138c84ca9339636138efbc2ac3f9754e216d7",
+        "sha256_in_prefix": "fbac1d9d715d97c3dbed0dcb541138c84ca9339636138efbc2ac3f9754e216d7",
+        "size_in_bytes": 7003
+      },
+      {
+        "_path": "Lib/html/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "8d69aeb50f77de6d84c51b9d01e08497983bafe9297cdd1620bf75aa1b1dba1c",
+        "sha256_in_prefix": "8d69aeb50f77de6d84c51b9d01e08497983bafe9297cdd1620bf75aa1b1dba1c",
+        "size_in_bytes": 4756
+      },
+      {
+        "_path": "Lib/html/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd518be6be6d5b47516c361ce19013db9255250b5ffb347de0f7bb91476e2ad0",
+        "sha256_in_prefix": "dd518be6be6d5b47516c361ce19013db9255250b5ffb347de0f7bb91476e2ad0",
+        "size_in_bytes": 3108
+      },
+      {
+        "_path": "Lib/html/__pycache__/entities.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c60b9398666a7e0c8803ed9cdf4a139fffc09e9249a989f0126f1e60c64d4a29",
+        "sha256_in_prefix": "c60b9398666a7e0c8803ed9cdf4a139fffc09e9249a989f0126f1e60c64d4a29",
+        "size_in_bytes": 50504
+      },
+      {
+        "_path": "Lib/html/__pycache__/parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "543bb1d16f07fc8a0b01d9c03fa9c47fc89e76bf46091eada360f866c63694e4",
+        "sha256_in_prefix": "543bb1d16f07fc8a0b01d9c03fa9c47fc89e76bf46091eada360f866c63694e4",
+        "size_in_bytes": 10838
+      },
+      {
+        "_path": "Lib/html/entities.py",
+        "path_type": "hardlink",
+        "sha256": "282b7cdd567bbbf3d7d7ccd49fae1d3ebc7f7ab64058d781193620913773731b",
+        "sha256_in_prefix": "282b7cdd567bbbf3d7d7ccd49fae1d3ebc7f7ab64058d781193620913773731b",
+        "size_in_bytes": 75383
+      },
+      {
+        "_path": "Lib/html/parser.py",
+        "path_type": "hardlink",
+        "sha256": "16aaf2af5459e50e0484af96476fdb58b229f04e46f0c8726fa2dc5ae3ad328d",
+        "sha256_in_prefix": "16aaf2af5459e50e0484af96476fdb58b229f04e46f0c8726fa2dc5ae3ad328d",
+        "size_in_bytes": 17392
+      },
+      {
+        "_path": "Lib/http/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "f20ee6263f81332dbb385e3bd5d51f1cdb075fb8d1dc8b0af7cd58747815749b",
+        "sha256_in_prefix": "f20ee6263f81332dbb385e3bd5d51f1cdb075fb8d1dc8b0af7cd58747815749b",
+        "size_in_bytes": 6732
+      },
+      {
+        "_path": "Lib/http/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b9b232a7b22b0d1346acd6fad08ec30beccc8281f8693ed3503325e2017cdab4",
+        "sha256_in_prefix": "b9b232a7b22b0d1346acd6fad08ec30beccc8281f8693ed3503325e2017cdab4",
+        "size_in_bytes": 6396
+      },
+      {
+        "_path": "Lib/http/__pycache__/client.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "92214fb7d2dd783e4f81d21fe21f62f4c7f3c0a7649f6ddd6b324be94136616e",
+        "sha256_in_prefix": "92214fb7d2dd783e4f81d21fe21f62f4c7f3c0a7649f6ddd6b324be94136616e",
+        "size_in_bytes": 35522
+      },
+      {
+        "_path": "Lib/http/__pycache__/cookiejar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fad0268cc57faa826491bb8a832e55648f34b1806685294e14bc64cffe227aa2",
+        "sha256_in_prefix": "fad0268cc57faa826491bb8a832e55648f34b1806685294e14bc64cffe227aa2",
+        "size_in_bytes": 53488
+      },
+      {
+        "_path": "Lib/http/__pycache__/cookies.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "14f030fa268d6df93ebdb4b4e58ab5f4b713e3d401c09f221ed974d45e150edf",
+        "sha256_in_prefix": "14f030fa268d6df93ebdb4b4e58ab5f4b713e3d401c09f221ed974d45e150edf",
+        "size_in_bytes": 15044
+      },
+      {
+        "_path": "Lib/http/__pycache__/server.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d732e2ccf8ae0da44aa8140e268149578d42c2f8b5ba7bd2e541356dc12b6521",
+        "sha256_in_prefix": "d732e2ccf8ae0da44aa8140e268149578d42c2f8b5ba7bd2e541356dc12b6521",
+        "size_in_bytes": 35015
+      },
+      {
+        "_path": "Lib/http/client.py",
+        "path_type": "hardlink",
+        "sha256": "697260c7684a212714202d0d3a710e5257e5493fb940f9f1b133d4a0de8ebe34",
+        "sha256_in_prefix": "697260c7684a212714202d0d3a710e5257e5493fb940f9f1b133d4a0de8ebe34",
+        "size_in_bytes": 56549
+      },
+      {
+        "_path": "Lib/http/cookiejar.py",
+        "path_type": "hardlink",
+        "sha256": "db6855e8be92ec0a6687fee7cd6f23f46417fb7ebc2ff1631a547e43df9747ec",
+        "sha256_in_prefix": "db6855e8be92ec0a6687fee7cd6f23f46417fb7ebc2ff1631a547e43df9747ec",
+        "size_in_bytes": 76835
+      },
+      {
+        "_path": "Lib/http/cookies.py",
+        "path_type": "hardlink",
+        "sha256": "90db84a895e9da62e09a0957a01b6a70cbf7614ab3df266b57627dfa53f33a9f",
+        "sha256_in_prefix": "90db84a895e9da62e09a0957a01b6a70cbf7614ab3df266b57627dfa53f33a9f",
+        "size_in_bytes": 19840
+      },
+      {
+        "_path": "Lib/http/server.py",
+        "path_type": "hardlink",
+        "sha256": "eab6637d0684b41fa55f823d2fba3ce83c3e9a55e0693ea0e6c140c3e1af6bd6",
+        "sha256_in_prefix": "eab6637d0684b41fa55f823d2fba3ce83c3e9a55e0693ea0e6c140c3e1af6bd6",
+        "size_in_bytes": 48231
+      },
+      {
+        "_path": "Lib/idlelib/CREDITS.txt",
+        "path_type": "hardlink",
+        "sha256": "c7a0cc61079c6e2df53457e63b413e0389f2c0061eb55e80229da932c8f8dbd6",
+        "sha256_in_prefix": "c7a0cc61079c6e2df53457e63b413e0389f2c0061eb55e80229da932c8f8dbd6",
+        "size_in_bytes": 1866
+      },
+      {
+        "_path": "Lib/idlelib/ChangeLog",
+        "path_type": "hardlink",
+        "sha256": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64",
+        "sha256_in_prefix": "b7f42699e5e5a7c82ebdf2a2962946b7228c933ece0ea7c0d7789f21a7dd7e64",
+        "size_in_bytes": 56360
+      },
+      {
+        "_path": "Lib/idlelib/HISTORY.txt",
+        "path_type": "hardlink",
+        "sha256": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c",
+        "sha256_in_prefix": "531067a78ad392f25631aba1d885f40786cf5f47854577162c9f90ff1f33164c",
+        "size_in_bytes": 10312
+      },
+      {
+        "_path": "Lib/idlelib/Icons/README.txt",
+        "path_type": "hardlink",
+        "sha256": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272",
+        "sha256_in_prefix": "60399d6129e3e486ce6b437bbf614ff4838bd4e7f42d461c3e5467cf3b4fa272",
+        "size_in_bytes": 443
+      },
+      {
+        "_path": "Lib/idlelib/Icons/folder.gif",
+        "path_type": "hardlink",
+        "sha256": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55",
+        "sha256_in_prefix": "7c98d566a13fd599d1c11a375f387fef69b6c595c4f18c5d88c188a860be0e55",
+        "size_in_bytes": 120
+      },
+      {
+        "_path": "Lib/idlelib/Icons/idle.ico",
+        "path_type": "hardlink",
+        "sha256": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55",
+        "sha256_in_prefix": "7f13eeb5dca39d05e24b9eb069c6dcb2748633822d67288a8bf8b7e21cdddf55",
+        "size_in_bytes": 57746
+      },
+      {
+        "_path": "Lib/idlelib/Icons/idle_16.gif",
+        "path_type": "hardlink",
+        "sha256": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e",
+        "sha256_in_prefix": "fe3af292b38660a8a58b1a8b4fa4240aa190602e7e9a700ea0536b3181fc968e",
+        "size_in_bytes": 634
+      },
+      {
+        "_path": "Lib/idlelib/Icons/idle_16.png",
+        "path_type": "hardlink",
+        "sha256": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e",
+        "sha256_in_prefix": "78fb3fb0ec11f61bc6cf0947f3c3923aa18e1c6513684058ed0fa01ac858143e",
+        "size_in_bytes": 1031
+      },
+      {
+        "_path": "Lib/idlelib/Icons/idle_256.png",
+        "path_type": "hardlink",
+        "sha256": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b",
+        "sha256_in_prefix": "3f517467d12e0e3ecf20f9bd68ce4bd18a2b8088f32308fd978fd80e87d3628b",
+        "size_in_bytes": 39205
+      },
+      {
+        "_path": "Lib/idlelib/Icons/idle_32.gif",
+        "path_type": "hardlink",
+        "sha256": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9",
+        "sha256_in_prefix": "fe70991cfccd1267922e94d91e02e9a58d2d29fd3382a2f4975280b9023cb7b9",
+        "size_in_bytes": 1019
+      },
+      {
+        "_path": "Lib/idlelib/Icons/idle_32.png",
+        "path_type": "hardlink",
+        "sha256": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de",
+        "sha256_in_prefix": "797cd05f1964d57c4c6c248ac7f7ea6a38019ada32a9ab7e6c28d060f87b03de",
+        "size_in_bytes": 2036
+      },
+      {
+        "_path": "Lib/idlelib/Icons/idle_48.gif",
+        "path_type": "hardlink",
+        "sha256": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe",
+        "sha256_in_prefix": "37484901eb40eefa846308e1da3ff6f240ea98f769a2afc3cf4fdba00327ecbe",
+        "size_in_bytes": 1388
+      },
+      {
+        "_path": "Lib/idlelib/Icons/idle_48.png",
+        "path_type": "hardlink",
+        "sha256": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23",
+        "sha256_in_prefix": "a09f433197c8870b12bb7859cc4c3fe2068908cb1ddbd4880ab0f6fee91b6c23",
+        "size_in_bytes": 3977
+      },
+      {
+        "_path": "Lib/idlelib/Icons/minusnode.gif",
+        "path_type": "hardlink",
+        "sha256": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3",
+        "sha256_in_prefix": "efa5aa1d1e3439ab85425bd2aa3a25b9e6c21309e672690cfb32219e1eb7a7f3",
+        "size_in_bytes": 75
+      },
+      {
+        "_path": "Lib/idlelib/Icons/openfolder.gif",
+        "path_type": "hardlink",
+        "sha256": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b",
+        "sha256_in_prefix": "9a59e2abf1840156e9db8f85a38822fd56ab79a139eb95ec86f1fba1bb87326b",
+        "size_in_bytes": 125
+      },
+      {
+        "_path": "Lib/idlelib/Icons/plusnode.gif",
+        "path_type": "hardlink",
+        "sha256": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb",
+        "sha256_in_prefix": "6ace9e90a2bcb16d06c4d78837137f2c14bc26b3bd9f24b7b6afeadb689bdafb",
+        "size_in_bytes": 78
+      },
+      {
+        "_path": "Lib/idlelib/Icons/python.gif",
+        "path_type": "hardlink",
+        "sha256": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377",
+        "sha256_in_prefix": "158c31382f8e5b41fded0c2aa9cc66a382928b003cdd8b5b0518836ad9c89377",
+        "size_in_bytes": 380
+      },
+      {
+        "_path": "Lib/idlelib/Icons/tk.gif",
+        "path_type": "hardlink",
+        "sha256": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad",
+        "sha256_in_prefix": "7f16cb2e322891dbd9101302c09ffda0c2a3a72d053bb8c0927d507414c59cad",
+        "size_in_bytes": 72
+      },
+      {
+        "_path": "Lib/idlelib/NEWS.txt",
+        "path_type": "hardlink",
+        "sha256": "25ff879f7875854ce68824f4e6dd2f5a68d7c1d94a2bbfeba8462ee6190faa3d",
+        "sha256_in_prefix": "25ff879f7875854ce68824f4e6dd2f5a68d7c1d94a2bbfeba8462ee6190faa3d",
+        "size_in_bytes": 51948
+      },
+      {
+        "_path": "Lib/idlelib/NEWS2x.txt",
+        "path_type": "hardlink",
+        "sha256": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7",
+        "sha256_in_prefix": "c89a3b513501ebace8e428aea68dce39d0af9f29196e08fc9ea49c99605e79e7",
+        "size_in_bytes": 27172
+      },
+      {
+        "_path": "Lib/idlelib/README.txt",
+        "path_type": "hardlink",
+        "sha256": "49f1916c72abf67bd30a78ad7b364c2ae6c8b3d234eaa7ee5ae6bc837cdbe7f5",
+        "sha256_in_prefix": "49f1916c72abf67bd30a78ad7b364c2ae6c8b3d234eaa7ee5ae6bc837cdbe7f5",
+        "size_in_bytes": 9680
+      },
+      {
+        "_path": "Lib/idlelib/TODO.txt",
+        "path_type": "hardlink",
+        "sha256": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89",
+        "sha256_in_prefix": "f88e0fb30fa0ab5d0dc3030442ed92713f34170336c4dd2623723dc34829df89",
+        "size_in_bytes": 8478
+      },
+      {
+        "_path": "Lib/idlelib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45",
+        "sha256_in_prefix": "3f8058df4fec56eb20ff67ff84c86fd3d9697e2384c5a290ed696f6d3187aa45",
+        "size_in_bytes": 396
+      },
+      {
+        "_path": "Lib/idlelib/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d",
+        "sha256_in_prefix": "f8f55514d26791588de02fe685af0ab129174b32ab93efa39faf6140b6795d9d",
+        "size_in_bytes": 159
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0704966d5a0319520bf031e2295304c9093ceeac3c7cb4b6a6b7f670c472542d",
+        "sha256_in_prefix": "0704966d5a0319520bf031e2295304c9093ceeac3c7cb4b6a6b7f670c472542d",
+        "size_in_bytes": 487
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7ffd85210e63d2f4cdcd17f05d32319e296d83993079492452bee07b2a7344c7",
+        "sha256_in_prefix": "7ffd85210e63d2f4cdcd17f05d32319e296d83993079492452bee07b2a7344c7",
+        "size_in_bytes": 248
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/autocomplete.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9ee7a7ef4e08b967a059a25aee61da596f27b32a0e7c7b54fa402a90c52e4a90",
+        "sha256_in_prefix": "9ee7a7ef4e08b967a059a25aee61da596f27b32a0e7c7b54fa402a90c52e4a90",
+        "size_in_bytes": 7071
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/autocomplete_w.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1cf0d50c3751016a304d8aa2f9c9e2949876e48327ff0a7236b4798f3376e366",
+        "sha256_in_prefix": "1cf0d50c3751016a304d8aa2f9c9e2949876e48327ff0a7236b4798f3376e366",
+        "size_in_bytes": 11220
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/autoexpand.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0d1bf4e8378d3ca67741028c29bd7bc6b04206a2c4f839088e34a39680e3386a",
+        "sha256_in_prefix": "0d1bf4e8378d3ca67741028c29bd7bc6b04206a2c4f839088e34a39680e3386a",
+        "size_in_bytes": 2795
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/browser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "369ba597ddf15a185dc3d2462baa8701b122e2988d94562a1ed89572e0e1f944",
+        "sha256_in_prefix": "369ba597ddf15a185dc3d2462baa8701b122e2988d94562a1ed89572e0e1f944",
+        "size_in_bytes": 9476
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/calltip.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b0d776a45c433b2da925581dadde5947bf5e1b3698e5c2ee99902257168a8f10",
+        "sha256_in_prefix": "b0d776a45c433b2da925581dadde5947bf5e1b3698e5c2ee99902257168a8f10",
+        "size_in_bytes": 5774
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/calltip_w.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "398850e5d300c6589d56f430252a10c7d4181d830ca03d8aefbb9bb261e72e76",
+        "sha256_in_prefix": "398850e5d300c6589d56f430252a10c7d4181d830ca03d8aefbb9bb261e72e76",
+        "size_in_bytes": 6171
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/codecontext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "210c611518568de8c72e6394cf5b7b364185b7920161a1c6a803a3b127db9640",
+        "sha256_in_prefix": "210c611518568de8c72e6394cf5b7b364185b7920161a1c6a803a3b127db9640",
+        "size_in_bytes": 8848
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/colorizer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "51b8a67106b8e429ae0d0ced1f4f07ee274b954b03f077c6f77a6c8d763cb29f",
+        "sha256_in_prefix": "51b8a67106b8e429ae0d0ced1f4f07ee274b954b03f077c6f77a6c8d763cb29f",
+        "size_in_bytes": 10228
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/config.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2c4cc3e2b21ca3fdae772c6ef3e9837260e837f3afe4e730149c8c8592848635",
+        "sha256_in_prefix": "2c4cc3e2b21ca3fdae772c6ef3e9837260e837f3afe4e730149c8c8592848635",
+        "size_in_bytes": 29806
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/config_key.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fd1c519d22c181a259702cc0e3f19c20e06c09b8374258f5803d9988d2308751",
+        "sha256_in_prefix": "fd1c519d22c181a259702cc0e3f19c20e06c09b8374258f5803d9988d2308751",
+        "size_in_bytes": 11449
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/configdialog.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "53fac90b96d3d7e897df8a4023fb91478996c1128a9468374702e2f25f84f86d",
+        "sha256_in_prefix": "53fac90b96d3d7e897df8a4023fb91478996c1128a9468374702e2f25f84f86d",
+        "size_in_bytes": 80317
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/debugger.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c9ecf12410efb9bdfaf145cf404d66fa026a202dce07c4f6e32115055be4722c",
+        "sha256_in_prefix": "c9ecf12410efb9bdfaf145cf404d66fa026a202dce07c4f6e32115055be4722c",
+        "size_in_bytes": 14242
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/debugger_r.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3edc19bf9edd9ef510a6e6e0726c7b2518c513f2dc9455e138c7cbda888609b1",
+        "sha256_in_prefix": "3edc19bf9edd9ef510a6e6e0726c7b2518c513f2dc9455e138c7cbda888609b1",
+        "size_in_bytes": 13955
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/debugobj.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "596cb6db46d17b5b892933818c43238bb6f323e3016d60e99966f2260381b0aa",
+        "sha256_in_prefix": "596cb6db46d17b5b892933818c43238bb6f323e3016d60e99966f2260381b0aa",
+        "size_in_bytes": 5237
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/debugobj_r.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e777ca563070a62d185a7c85981a3d1c1a367ce78aea133a7b7b9413120d86ac",
+        "sha256_in_prefix": "e777ca563070a62d185a7c85981a3d1c1a367ce78aea133a7b7b9413120d86ac",
+        "size_in_bytes": 1992
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/delegator.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2e6a63cb2cc4a397a4eb680f76dec41bd7dabc1ca4637a6b2bb2f69d675002d0",
+        "sha256_in_prefix": "2e6a63cb2cc4a397a4eb680f76dec41bd7dabc1ca4637a6b2bb2f69d675002d0",
+        "size_in_bytes": 1263
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/dynoption.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ee154d3912eefcf468477ad05dd2a1b2968e3f855b7cd0cf94e0dbfab31e7b59",
+        "sha256_in_prefix": "ee154d3912eefcf468477ad05dd2a1b2968e3f855b7cd0cf94e0dbfab31e7b59",
+        "size_in_bytes": 2285
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/editor.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2c3179933d6df65e483e8b9684cada478701c358b9dc6cc2f20184fd2e5753dc",
+        "sha256_in_prefix": "2c3179933d6df65e483e8b9684cada478701c358b9dc6cc2f20184fd2e5753dc",
+        "size_in_bytes": 46877
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/filelist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "803de6f330012929a07c5fe135a8359d9ee66092a2e1b6fec783255da9d32ca9",
+        "sha256_in_prefix": "803de6f330012929a07c5fe135a8359d9ee66092a2e1b6fec783255da9d32ca9",
+        "size_in_bytes": 3386
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/format.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4132535d9198fe6f80d1fef90640c5c0d5d3d9d256aee28e3f4edfba97900ce4",
+        "sha256_in_prefix": "4132535d9198fe6f80d1fef90640c5c0d5d3d9d256aee28e3f4edfba97900ce4",
+        "size_in_bytes": 13361
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/grep.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d45d22fa116a964430509bfea9b84a6bdde41f3f7a876b38c6d681c712a65a02",
+        "sha256_in_prefix": "d45d22fa116a964430509bfea9b84a6bdde41f3f7a876b38c6d681c712a65a02",
+        "size_in_bytes": 7821
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/help.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6f4525abd071338fa91a95597b3852cde9bff8eb37ccfc543fcd453dfedaa4f8",
+        "sha256_in_prefix": "6f4525abd071338fa91a95597b3852cde9bff8eb37ccfc543fcd453dfedaa4f8",
+        "size_in_bytes": 10586
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/help_about.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "151546258f95a1d882a5e7d19ec2c4c6d5000c3705ca476d002e9fe36019d0dd",
+        "sha256_in_prefix": "151546258f95a1d882a5e7d19ec2c4c6d5000c3705ca476d002e9fe36019d0dd",
+        "size_in_bytes": 7633
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/history.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "66d48f3ba35f8d3f5a85488afd0dba9773dd076560917a511ffa089519cc8f5b",
+        "sha256_in_prefix": "66d48f3ba35f8d3f5a85488afd0dba9773dd076560917a511ffa089519cc8f5b",
+        "size_in_bytes": 3379
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/hyperparser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "599d113f686b45917c1bb9d0c170a883a14a70d713f5d84c1a4d20ec5d5fa064",
+        "sha256_in_prefix": "599d113f686b45917c1bb9d0c170a883a14a70d713f5d84c1a4d20ec5d5fa064",
+        "size_in_bytes": 6758
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/idle.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3e15a17f53247c97b73f00a2f8d8b277b258666b1c7ffba4ed632c96dd667907",
+        "sha256_in_prefix": "3e15a17f53247c97b73f00a2f8d8b277b258666b1c7ffba4ed632c96dd667907",
+        "size_in_bytes": 313
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/iomenu.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4526a70d7d24f6851fa9bb49d2014f6af2098fca0eb6e40b927f52ea7495b173",
+        "sha256_in_prefix": "4526a70d7d24f6851fa9bb49d2014f6af2098fca0eb6e40b927f52ea7495b173",
+        "size_in_bytes": 11708
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/macosx.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e906c609cff0c44f2e89e23e17deecd140527eab4ddc1f20fe60736a208b3512",
+        "sha256_in_prefix": "e906c609cff0c44f2e89e23e17deecd140527eab4ddc1f20fe60736a208b3512",
+        "size_in_bytes": 7629
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/mainmenu.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "852a89e436d511932a93373b3ce1404172815863e3dd8d81725a6ec35a0431b2",
+        "sha256_in_prefix": "852a89e436d511932a93373b3ce1404172815863e3dd8d81725a6ec35a0431b2",
+        "size_in_bytes": 3240
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/multicall.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d05240d4a3047491fbda4468e789085c04033845598284553aff47acdff3b6dc",
+        "sha256_in_prefix": "d05240d4a3047491fbda4468e789085c04033845598284553aff47acdff3b6dc",
+        "size_in_bytes": 14946
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/outwin.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1c3b9e33889de21f73b102977a639c8d6a2a55cc52e8afa1e3d775fa762581c9",
+        "sha256_in_prefix": "1c3b9e33889de21f73b102977a639c8d6a2a55cc52e8afa1e3d775fa762581c9",
+        "size_in_bytes": 5978
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/parenmatch.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "828a38815715c97fefa90b25f985a34496aa5a5e1eae5f9698007a44676a6d57",
+        "sha256_in_prefix": "828a38815715c97fefa90b25f985a34496aa5a5e1eae5f9698007a44676a6d57",
+        "size_in_bytes": 6320
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/pathbrowser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7897635c51833d2cbf7bd86d5540af34d2b7fbb3478c61b308d9080363749d9a",
+        "sha256_in_prefix": "7897635c51833d2cbf7bd86d5540af34d2b7fbb3478c61b308d9080363749d9a",
+        "size_in_bytes": 3753
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/percolator.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bc045c46b3b9e45adef3380440c15b0a725f584cc408f7f0af7321ed2bd1d751",
+        "sha256_in_prefix": "bc045c46b3b9e45adef3380440c15b0a725f584cc408f7f0af7321ed2bd1d751",
+        "size_in_bytes": 3660
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/pyparse.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "540dc0befcb1b7ccac23314436da03d97567ce78650e241397932a3c43e33263",
+        "sha256_in_prefix": "540dc0befcb1b7ccac23314436da03d97567ce78650e241397932a3c43e33263",
+        "size_in_bytes": 11949
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/pyshell.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8f0f05362d6b834f069310a8af5d97c8b5fbd1b794c3e229de70975bba2c415d",
+        "sha256_in_prefix": "8f0f05362d6b834f069310a8af5d97c8b5fbd1b794c3e229de70975bba2c415d",
+        "size_in_bytes": 42770
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/query.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "781bf621e0dec204c0bf971d7ab40dde5151309d03b9acea02a1e19148de72f7",
+        "sha256_in_prefix": "781bf621e0dec204c0bf971d7ab40dde5151309d03b9acea02a1e19148de72f7",
+        "size_in_bytes": 12831
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/redirector.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cbedf3decc7b434425013faf300fdded7ecebdf42ed96a9fae5a2505f84f4875",
+        "sha256_in_prefix": "cbedf3decc7b434425013faf300fdded7ecebdf42ed96a9fae5a2505f84f4875",
+        "size_in_bytes": 6775
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/replace.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b5ca6161d3dee315b00c76aed52c14c4ed23796902dcac7ef63877fe713f44ef",
+        "sha256_in_prefix": "b5ca6161d3dee315b00c76aed52c14c4ed23796902dcac7ef63877fe713f44ef",
+        "size_in_bytes": 9333
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/rpc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "19144a046f596b0ff716dc136510cd08c988c36f84300bf4e9c125b06d1f71ea",
+        "sha256_in_prefix": "19144a046f596b0ff716dc136510cd08c988c36f84300bf4e9c125b06d1f71ea",
+        "size_in_bytes": 19690
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/run.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "24c6320d29ec750a55ba2a1d11d081bfbc623bb3aea24991f5bb1fa7a6c17a1e",
+        "sha256_in_prefix": "24c6320d29ec750a55ba2a1d11d081bfbc623bb3aea24991f5bb1fa7a6c17a1e",
+        "size_in_bytes": 18351
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/runscript.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1f5e7396505739e53776ab05e5818176aa7ad1c6a99079407a0853bbce653048",
+        "sha256_in_prefix": "1f5e7396505739e53776ab05e5818176aa7ad1c6a99079407a0853bbce653048",
+        "size_in_bytes": 6838
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/scrolledlist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1be1bf7b49480ccce846f4666d5133da8e050237030dad9136c33209cad06b7f",
+        "sha256_in_prefix": "1be1bf7b49480ccce846f4666d5133da8e050237030dad9136c33209cad06b7f",
+        "size_in_bytes": 5309
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/search.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "db89b9fc72c7b037a4cf5cb86fe3d845b8b6ebb4ab852e8f44d77fb40cacdc69",
+        "sha256_in_prefix": "db89b9fc72c7b037a4cf5cb86fe3d845b8b6ebb4ab852e8f44d77fb40cacdc69",
+        "size_in_bytes": 5921
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/searchbase.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "43305d3ac0bab58588c0661b6f4f9718503d800dbed7e65efa26a743ee59b323",
+        "sha256_in_prefix": "43305d3ac0bab58588c0661b6f4f9718503d800dbed7e65efa26a743ee59b323",
+        "size_in_bytes": 8305
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/searchengine.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1a221562cc96dfe0f4b7635ba4d5946719e8ccbd1549351c54e04e5b43c7127a",
+        "sha256_in_prefix": "1a221562cc96dfe0f4b7635ba4d5946719e8ccbd1549351c54e04e5b43c7127a",
+        "size_in_bytes": 6757
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/sidebar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e83c4b7acaff2cfef511e1fe826185ef2f7bb35b47b71e1e660ff2c506211e83",
+        "sha256_in_prefix": "e83c4b7acaff2cfef511e1fe826185ef2f7bb35b47b71e1e660ff2c506211e83",
+        "size_in_bytes": 10939
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/squeezer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "074ca6fa2ac0fb0fabab178a5fcaf5c0b8f0c2d5ed98df1f485a9da5fb50199e",
+        "sha256_in_prefix": "074ca6fa2ac0fb0fabab178a5fcaf5c0b8f0c2d5ed98df1f485a9da5fb50199e",
+        "size_in_bytes": 9526
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/stackviewer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "53607ef21784f767408ab2af2796faddb02addf9dc342f42cded8709e74b4528",
+        "sha256_in_prefix": "53607ef21784f767408ab2af2796faddb02addf9dc342f42cded8709e74b4528",
+        "size_in_bytes": 5102
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/statusbar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b12d7d20ad43e6ec716604e6601a3c362dae67a46220703134be70bb897b5553",
+        "sha256_in_prefix": "b12d7d20ad43e6ec716604e6601a3c362dae67a46220703134be70bb897b5553",
+        "size_in_bytes": 1970
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/textview.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0f552f22eee8f378c41600b52afd99f72cdcb0cc9a3f887c0ef03c17e7d4291e",
+        "sha256_in_prefix": "0f552f22eee8f378c41600b52afd99f72cdcb0cc9a3f887c0ef03c17e7d4291e",
+        "size_in_bytes": 7037
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/tooltip.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0400d7c7ce44610ea30c1d59b8abafef63f891d2397a09b846711b0fc6ac4ca1",
+        "sha256_in_prefix": "0400d7c7ce44610ea30c1d59b8abafef63f891d2397a09b846711b0fc6ac4ca1",
+        "size_in_bytes": 6542
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/tree.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d7aed1a99712bc9ab890bd322de37074276034d1da4faa3c75bdcbc7d52983f8",
+        "sha256_in_prefix": "d7aed1a99712bc9ab890bd322de37074276034d1da4faa3c75bdcbc7d52983f8",
+        "size_in_bytes": 15681
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/undo.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4acdd9a3c9904424205cbe267cb08ed78acca0cfe966f5ad497654cc598f6ac6",
+        "sha256_in_prefix": "4acdd9a3c9904424205cbe267cb08ed78acca0cfe966f5ad497654cc598f6ac6",
+        "size_in_bytes": 10812
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ab35b5488e8e827b32b92fbe0d6f21baef1ea41c6a8f5822d2b4a342c325250f",
+        "sha256_in_prefix": "ab35b5488e8e827b32b92fbe0d6f21baef1ea41c6a8f5822d2b4a342c325250f",
+        "size_in_bytes": 785
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/window.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3cb79b029f23bcc54a1ba73b053f283d2e7654058d5c8852db13bb450e1b39ad",
+        "sha256_in_prefix": "3cb79b029f23bcc54a1ba73b053f283d2e7654058d5c8852db13bb450e1b39ad",
+        "size_in_bytes": 3196
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/zoomheight.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "da36298e3e7bdd45883fd03809c7cc7c028d373c46ed414e255f80d384e7119a",
+        "sha256_in_prefix": "da36298e3e7bdd45883fd03809c7cc7c028d373c46ed414e255f80d384e7119a",
+        "size_in_bytes": 2808
+      },
+      {
+        "_path": "Lib/idlelib/__pycache__/zzdummy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a2f1a347283ffdbc60537e041a4efa867c4697ee7bb86962c43397e7259c5d5d",
+        "sha256_in_prefix": "a2f1a347283ffdbc60537e041a4efa867c4697ee7bb86962c43397e7259c5d5d",
+        "size_in_bytes": 2455
+      },
+      {
+        "_path": "Lib/idlelib/autocomplete.py",
+        "path_type": "hardlink",
+        "sha256": "aea7f05434b2d007abf89b4316a7961e3663747d25812f2df57da986677451e3",
+        "sha256_in_prefix": "aea7f05434b2d007abf89b4316a7961e3663747d25812f2df57da986677451e3",
+        "size_in_bytes": 9150
+      },
+      {
+        "_path": "Lib/idlelib/autocomplete_w.py",
+        "path_type": "hardlink",
+        "sha256": "6aed67daa243db8258edbe04a74d21d9649b731169a4d8a332a6dd216a80c586",
+        "sha256_in_prefix": "6aed67daa243db8258edbe04a74d21d9649b731169a4d8a332a6dd216a80c586",
+        "size_in_bytes": 20981
+      },
+      {
+        "_path": "Lib/idlelib/autoexpand.py",
+        "path_type": "hardlink",
+        "sha256": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e",
+        "sha256_in_prefix": "c8eb28ef7addf5a664a7e3addfbfebe29040a8695e1db515828305aacba2ee4e",
+        "size_in_bytes": 3216
+      },
+      {
+        "_path": "Lib/idlelib/browser.py",
+        "path_type": "hardlink",
+        "sha256": "1ed86d69babfddef46e725ca8ed3521ee711867cf312868b465bcc383ce7f8e6",
+        "sha256_in_prefix": "1ed86d69babfddef46e725ca8ed3521ee711867cf312868b465bcc383ce7f8e6",
+        "size_in_bytes": 8314
+      },
+      {
+        "_path": "Lib/idlelib/calltip.py",
+        "path_type": "hardlink",
+        "sha256": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590",
+        "sha256_in_prefix": "3a723fdf88c0018dfadd19757142a643b01b785c6df17a50bbe21463663ab590",
+        "size_in_bytes": 7267
+      },
+      {
+        "_path": "Lib/idlelib/calltip_w.py",
+        "path_type": "hardlink",
+        "sha256": "f60fde563751ad8d77dfcd892558d6c4306764d9affade5018147e84c7246900",
+        "sha256_in_prefix": "f60fde563751ad8d77dfcd892558d6c4306764d9affade5018147e84c7246900",
+        "size_in_bytes": 7158
+      },
+      {
+        "_path": "Lib/idlelib/codecontext.py",
+        "path_type": "hardlink",
+        "sha256": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492",
+        "sha256_in_prefix": "628a13325b3bf2f76dea9254b20178b3232261f83c660f0e33785e6215dd6492",
+        "size_in_bytes": 11420
+      },
+      {
+        "_path": "Lib/idlelib/colorizer.py",
+        "path_type": "hardlink",
+        "sha256": "8aa3fcbcec10b0cdf0238ea95c0ce75304dfd92f408110994be3859c8af68080",
+        "sha256_in_prefix": "8aa3fcbcec10b0cdf0238ea95c0ce75304dfd92f408110994be3859c8af68080",
+        "size_in_bytes": 13201
+      },
+      {
+        "_path": "Lib/idlelib/config-extensions.def",
+        "path_type": "hardlink",
+        "sha256": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf",
+        "sha256_in_prefix": "e75df0b77ff61253be457af636d5eb7c55a3ff2b6a733beea844d2b294972ebf",
+        "size_in_bytes": 2266
+      },
+      {
+        "_path": "Lib/idlelib/config-highlight.def",
+        "path_type": "hardlink",
+        "sha256": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547",
+        "sha256_in_prefix": "609eada44ff4aa9d5cd10ad8b4c29bb76db8ebc74912a0ae86f5ea3cd19b7547",
+        "size_in_bytes": 2864
+      },
+      {
+        "_path": "Lib/idlelib/config-keys.def",
+        "path_type": "hardlink",
+        "sha256": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710",
+        "sha256_in_prefix": "bee81ba5c5abec1e35e313268f8d8fe72d305d0ad73abfba3d2ea1e2b2308710",
+        "size_in_bytes": 10910
+      },
+      {
+        "_path": "Lib/idlelib/config-main.def",
+        "path_type": "hardlink",
+        "sha256": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87",
+        "sha256_in_prefix": "e783704ad5cd9b3f44c026f55c98be2c52190bf9b7832251283f3e953ba80f87",
+        "size_in_bytes": 3168
+      },
+      {
+        "_path": "Lib/idlelib/config.py",
+        "path_type": "hardlink",
+        "sha256": "593a992db63dcaa31afcd8477dad4c1b74e4f1e636c01bb845ad6b74f722ce74",
+        "sha256_in_prefix": "593a992db63dcaa31afcd8477dad4c1b74e4f1e636c01bb845ad6b74f722ce74",
+        "size_in_bytes": 38173
+      },
+      {
+        "_path": "Lib/idlelib/config_key.py",
+        "path_type": "hardlink",
+        "sha256": "8362050d410d0fa0b2e5a51242dd61dff6e858a8ed4d5f7324ad71e8677fd20c",
+        "sha256_in_prefix": "8362050d410d0fa0b2e5a51242dd61dff6e858a8ed4d5f7324ad71e8677fd20c",
+        "size_in_bytes": 14540
+      },
+      {
+        "_path": "Lib/idlelib/configdialog.py",
+        "path_type": "hardlink",
+        "sha256": "55352c6a5cc42027629e667d3596b692a7be31cf6f22b2c4e690fd81e645b552",
+        "sha256_in_prefix": "55352c6a5cc42027629e667d3596b692a7be31cf6f22b2c4e690fd81e645b552",
+        "size_in_bytes": 105738
+      },
+      {
+        "_path": "Lib/idlelib/debugger.py",
+        "path_type": "hardlink",
+        "sha256": "126415c89631586d2f51931274a2d8c3dde2c9a4132e8a1f6954c97de78aa417",
+        "sha256_in_prefix": "126415c89631586d2f51931274a2d8c3dde2c9a4132e8a1f6954c97de78aa417",
+        "size_in_bytes": 19104
+      },
+      {
+        "_path": "Lib/idlelib/debugger_r.py",
+        "path_type": "hardlink",
+        "sha256": "ca94d058b89af51dbad41ae8b7e20973fdaa0c31e1fb29b141499e6339d29f55",
+        "sha256_in_prefix": "ca94d058b89af51dbad41ae8b7e20973fdaa0c31e1fb29b141499e6339d29f55",
+        "size_in_bytes": 12167
+      },
+      {
+        "_path": "Lib/idlelib/debugobj.py",
+        "path_type": "hardlink",
+        "sha256": "db8add0abc885fc629c6746aca77cd40026b2dac8d7edb93f1fcf6ea9d28334f",
+        "sha256_in_prefix": "db8add0abc885fc629c6746aca77cd40026b2dac8d7edb93f1fcf6ea9d28334f",
+        "size_in_bytes": 4055
+      },
+      {
+        "_path": "Lib/idlelib/debugobj_r.py",
+        "path_type": "hardlink",
+        "sha256": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11",
+        "sha256_in_prefix": "4e583b43fdf9bd4a731d70e074ee597aba03f3c8c36302bdc7e74650fb1fcc11",
+        "size_in_bytes": 1082
+      },
+      {
+        "_path": "Lib/idlelib/delegator.py",
+        "path_type": "hardlink",
+        "sha256": "3b79bbd9ef3bc789559f5af7b0c844d5292ae02368d167dd5751ead2343109d5",
+        "sha256_in_prefix": "3b79bbd9ef3bc789559f5af7b0c844d5292ae02368d167dd5751ead2343109d5",
+        "size_in_bytes": 1043
+      },
+      {
+        "_path": "Lib/idlelib/dynoption.py",
+        "path_type": "hardlink",
+        "sha256": "1595e2034eaa93c2ca61854038e64197541906b3402c448b176e34a5af9b6b09",
+        "sha256_in_prefix": "1595e2034eaa93c2ca61854038e64197541906b3402c448b176e34a5af9b6b09",
+        "size_in_bytes": 2017
+      },
+      {
+        "_path": "Lib/idlelib/editor.py",
+        "path_type": "hardlink",
+        "sha256": "2655932beb3956110133adadb8c867f1646b9b9b351f8b54938deade3287e9ed",
+        "sha256_in_prefix": "2655932beb3956110133adadb8c867f1646b9b9b351f8b54938deade3287e9ed",
+        "size_in_bytes": 65733
+      },
+      {
+        "_path": "Lib/idlelib/extend.txt",
+        "path_type": "hardlink",
+        "sha256": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853",
+        "sha256_in_prefix": "5bceaf660c46faf8f9fbf2be5e23389d6e6477d1e458fee680e606bcc95d2853",
+        "size_in_bytes": 3631
+      },
+      {
+        "_path": "Lib/idlelib/filelist.py",
+        "path_type": "hardlink",
+        "sha256": "b2923b72d89db91bda3abdfc9a7a42789e4a20a70f4ff8cab0a737995249f0d3",
+        "sha256_in_prefix": "b2923b72d89db91bda3abdfc9a7a42789e4a20a70f4ff8cab0a737995249f0d3",
+        "size_in_bytes": 3876
+      },
+      {
+        "_path": "Lib/idlelib/format.py",
+        "path_type": "hardlink",
+        "sha256": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c",
+        "sha256_in_prefix": "dc2b00fb239f38543bf973d94daef2c52457b905d4d89c640993823127b7923c",
+        "size_in_bytes": 15777
+      },
+      {
+        "_path": "Lib/idlelib/grep.py",
+        "path_type": "hardlink",
+        "sha256": "fb50ba574b03745100cdaed82ae64105baac6a43cfb52ed4af5e7c2a9579ee9f",
+        "sha256_in_prefix": "fb50ba574b03745100cdaed82ae64105baac6a43cfb52ed4af5e7c2a9579ee9f",
+        "size_in_bytes": 7479
+      },
+      {
+        "_path": "Lib/idlelib/help.html",
+        "path_type": "hardlink",
+        "sha256": "b606f1551c9ccfa6774548117cc0f08d37fdf1d4de98e7835babc60628ad84f1",
+        "sha256_in_prefix": "b606f1551c9ccfa6774548117cc0f08d37fdf1d4de98e7835babc60628ad84f1",
+        "size_in_bytes": 68554
+      },
+      {
+        "_path": "Lib/idlelib/help.py",
+        "path_type": "hardlink",
+        "sha256": "f7b1d6913c9f1c3c9b50e281070d3a74107ff73c34e679a562acc0d8437361df",
+        "sha256_in_prefix": "f7b1d6913c9f1c3c9b50e281070d3a74107ff73c34e679a562acc0d8437361df",
+        "size_in_bytes": 11851
+      },
+      {
+        "_path": "Lib/idlelib/help_about.py",
+        "path_type": "hardlink",
+        "sha256": "9d2934a2c3b8b6caded0f6c49822a3145c4b1a8e74614c8023648323a9e80ade",
+        "sha256_in_prefix": "9d2934a2c3b8b6caded0f6c49822a3145c4b1a8e74614c8023648323a9e80ade",
+        "size_in_bytes": 9084
+      },
+      {
+        "_path": "Lib/idlelib/history.py",
+        "path_type": "hardlink",
+        "sha256": "8d5bfe68f86077f533d16672ca4012c39f3da3e73579832489dbfacf9c4dafab",
+        "sha256_in_prefix": "8d5bfe68f86077f533d16672ca4012c39f3da3e73579832489dbfacf9c4dafab",
+        "size_in_bytes": 4043
+      },
+      {
+        "_path": "Lib/idlelib/hyperparser.py",
+        "path_type": "hardlink",
+        "sha256": "dd5ab81a21fb930667df540b076fb1bc29680a22053ec8d24a6265a51a0345c4",
+        "sha256_in_prefix": "dd5ab81a21fb930667df540b076fb1bc29680a22053ec8d24a6265a51a0345c4",
+        "size_in_bytes": 12883
+      },
+      {
+        "_path": "Lib/idlelib/idle.bat",
+        "path_type": "hardlink",
+        "sha256": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114",
+        "sha256_in_prefix": "15a3977f0d2c6a8e87db2ef7050ea10afb3a88b064bf5ef95439924e42464114",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "Lib/idlelib/idle.py",
+        "path_type": "hardlink",
+        "sha256": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a",
+        "sha256_in_prefix": "33ffa2f718e123fd1c4e536bb4a471978515787ee9fbf7806a92073a787a733a",
+        "size_in_bytes": 454
+      },
+      {
+        "_path": "Lib/idlelib/idle.pyw",
+        "path_type": "hardlink",
+        "sha256": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c",
+        "sha256_in_prefix": "26101d297127132c5e9634499f41ad00e125ea308343a20b278bee9e9225eb5c",
+        "size_in_bytes": 570
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/README.txt",
+        "path_type": "hardlink",
+        "sha256": "bfe6188362a0bc7db8b94c3dd313b97c83ad6d10b79451fd2a8a4bd773cd392b",
+        "sha256_in_prefix": "bfe6188362a0bc7db8b94c3dd313b97c83ad6d10b79451fd2a8a4bd773cd392b",
+        "size_in_bytes": 8729
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "228f8efbf4c316bd701b09a72b084a08248e26a346c6a7636a142391a8b3e674",
+        "sha256_in_prefix": "228f8efbf4c316bd701b09a72b084a08248e26a346c6a7636a142391a8b3e674",
+        "size_in_bytes": 712
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e4ebce257f500eb844d1c2b26df4326205aac9d07de6a8898d95f33eb9b8f9a9",
+        "sha256_in_prefix": "e4ebce257f500eb844d1c2b26df4326205aac9d07de6a8898d95f33eb9b8f9a9",
+        "size_in_bytes": 834
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/htest.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7061eca126feecc59873d74c6375a1f5b3ef1bbcbb2072486cf5f1fde0aadc8e",
+        "sha256_in_prefix": "7061eca126feecc59873d74c6375a1f5b3ef1bbcbb2072486cf5f1fde0aadc8e",
+        "size_in_bytes": 13911
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/mock_idle.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4e8e22adad756adc9048c6708f479442c941acdab78aaf9d24dd6a87fd785614",
+        "sha256_in_prefix": "4e8e22adad756adc9048c6708f479442c941acdab78aaf9d24dd6a87fd785614",
+        "size_in_bytes": 2621
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/mock_tk.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dc8d72a575a87c6bedd188e883c61674d7a17856c1384c6d41d2bf888a4fc578",
+        "sha256_in_prefix": "dc8d72a575a87c6bedd188e883c61674d7a17856c1384c6d41d2bf888a4fc578",
+        "size_in_bytes": 10875
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/template.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "76202cdf38a8651c26060ba40d2b952099d238d3c5a549f74494d8f0c4f06625",
+        "sha256_in_prefix": "76202cdf38a8651c26060ba40d2b952099d238d3c5a549f74494d8f0c4f06625",
+        "size_in_bytes": 1043
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_autocomplete.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a9b489e15fd97d525c51c52507f6e5b8a769abe440d1d831d407d3843412854b",
+        "sha256_in_prefix": "a9b489e15fd97d525c51c52507f6e5b8a769abe440d1d831d407d3843412854b",
+        "size_in_bytes": 9466
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_autocomplete_w.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d0c361bc079eb2a141f0522d19e267716454925c4db1f10f93197b339be92e14",
+        "sha256_in_prefix": "d0c361bc079eb2a141f0522d19e267716454925c4db1f10f93197b339be92e14",
+        "size_in_bytes": 1291
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_autoexpand.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9d31b572d64d89f1251e7add74fbfdd5c69ec4b4afb6b481424af2320343d6fa",
+        "sha256_in_prefix": "9d31b572d64d89f1251e7add74fbfdd5c69ec4b4afb6b481424af2320343d6fa",
+        "size_in_bytes": 3931
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_browser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9f59927e38cfa102797b49491fe586fb29df91efb484f447befc5aaa884a6c3b",
+        "sha256_in_prefix": "9f59927e38cfa102797b49491fe586fb29df91efb484f447befc5aaa884a6c3b",
+        "size_in_bytes": 8934
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_calltip.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "41aa0942a8faff4af02615eeba7cc2c24525cd0458676f18e1c183d839d29a8d",
+        "sha256_in_prefix": "41aa0942a8faff4af02615eeba7cc2c24525cd0458676f18e1c183d839d29a8d",
+        "size_in_bytes": 18821
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_calltip_w.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "27aac1786ec39334cc26e57f280e9cb9064caeb184796b60a0b004a38ab4d332",
+        "sha256_in_prefix": "27aac1786ec39334cc26e57f280e9cb9064caeb184796b60a0b004a38ab4d332",
+        "size_in_bytes": 1243
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_codecontext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e16b6799d446f8822c1cbc2f8d36ce996e2245d504477565bf0e7d9e04b152b9",
+        "sha256_in_prefix": "e16b6799d446f8822c1cbc2f8d36ce996e2245d504477565bf0e7d9e04b152b9",
+        "size_in_bytes": 11261
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_colorizer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a853ac07045e20ca308b9fc2c006d33e75c5d97e9f364fe7f45b9ec84d19f08d",
+        "sha256_in_prefix": "a853ac07045e20ca308b9fc2c006d33e75c5d97e9f364fe7f45b9ec84d19f08d",
+        "size_in_bytes": 12114
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_config.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "32e74671232878944a769cc417ae589355d3abd25b4d8e535b499d3f14074f3b",
+        "sha256_in_prefix": "32e74671232878944a769cc417ae589355d3abd25b4d8e535b499d3f14074f3b",
+        "size_in_bytes": 25273
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_config_key.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "40ffe66e8991a330b36651a3122a7d4d4f9fd445a3fe3814cbe9e6c7cbe26f3f",
+        "sha256_in_prefix": "40ffe66e8991a330b36651a3122a7d4d4f9fd445a3fe3814cbe9e6c7cbe26f3f",
+        "size_in_bytes": 10755
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_configdialog.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c0a01dcb2fbf7ccc1a24133757f4bd7c89b0aba5b85482403786b938986edabc",
+        "sha256_in_prefix": "c0a01dcb2fbf7ccc1a24133757f4bd7c89b0aba5b85482403786b938986edabc",
+        "size_in_bytes": 41886
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_debugger.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dadec600d51d34e1ffb2ce2b12893d153b31badf6e5df446754758bee5d3ed96",
+        "sha256_in_prefix": "dadec600d51d34e1ffb2ce2b12893d153b31badf6e5df446754758bee5d3ed96",
+        "size_in_bytes": 1085
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_debugger_r.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7d06e03bb2e3d42c533a0f399830bd477b1a842fc3ad858706c6b69b0baf29f7",
+        "sha256_in_prefix": "7d06e03bb2e3d42c533a0f399830bd477b1a842fc3ad858706c6b69b0baf29f7",
+        "size_in_bytes": 1444
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_debugobj.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b3c9a6dbb6efae77ab7b62ea4f0dc5d87900ecacd802f75219634eda1a2cf8c1",
+        "sha256_in_prefix": "b3c9a6dbb6efae77ab7b62ea4f0dc5d87900ecacd802f75219634eda1a2cf8c1",
+        "size_in_bytes": 2646
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_debugobj_r.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0a72dc83a6b46d7b2b40873e993e6f1483576c4091a4b0879ac36511fc6e55d6",
+        "sha256_in_prefix": "0a72dc83a6b46d7b2b40873e993e6f1483576c4091a4b0879ac36511fc6e55d6",
+        "size_in_bytes": 1096
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_delegator.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "39151fc5738492998ece27c9963499f0e028fd277f1fbf2364e530b3c04373e9",
+        "sha256_in_prefix": "39151fc5738492998ece27c9963499f0e028fd277f1fbf2364e530b3c04373e9",
+        "size_in_bytes": 1055
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_editmenu.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9481caec5222e686aeb44b16eb6537d3f417aeed2cc6424fd68d93839c14aae7",
+        "sha256_in_prefix": "9481caec5222e686aeb44b16eb6537d3f417aeed2cc6424fd68d93839c14aae7",
+        "size_in_bytes": 2762
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_editor.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2374e005cd86bece31a048c8a7000725ac16e696187d5dd39f113f472de65783",
+        "sha256_in_prefix": "2374e005cd86bece31a048c8a7000725ac16e696187d5dd39f113f472de65783",
+        "size_in_bytes": 6564
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_filelist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c64a8660b525d83ca1b7716c1178941e578d0ee818e5a8fb7a12f82511f6a1a8",
+        "sha256_in_prefix": "c64a8660b525d83ca1b7716c1178941e578d0ee818e5a8fb7a12f82511f6a1a8",
+        "size_in_bytes": 1305
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_format.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5cb865890859d68de8312d364e1a5686283e335213effa047c804e84d00d8164",
+        "sha256_in_prefix": "5cb865890859d68de8312d364e1a5686283e335213effa047c804e84d00d8164",
+        "size_in_bytes": 20489
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_grep.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d886d154d6863eb65e5931d6111656c67596abf2cfa8c7f788d2481721ccbc3",
+        "sha256_in_prefix": "2d886d154d6863eb65e5931d6111656c67596abf2cfa8c7f788d2481721ccbc3",
+        "size_in_bytes": 4962
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_help.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "860e9c59b6044473d0e8cf7e9ac4ff29141f54730a8a161ae4f7819678d9e6e0",
+        "sha256_in_prefix": "860e9c59b6044473d0e8cf7e9ac4ff29141f54730a8a161ae4f7819678d9e6e0",
+        "size_in_bytes": 1401
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_help_about.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd786f8410e5fb6022782c24c5e9e6fdab802e926d37d480cb702723cacaba87",
+        "sha256_in_prefix": "dd786f8410e5fb6022782c24c5e9e6fdab802e926d37d480cb702723cacaba87",
+        "size_in_bytes": 6716
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_history.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6072fe3bde5d60ce63564e0430a5dd4581bb2054169711e38f56f3843476086a",
+        "sha256_in_prefix": "6072fe3bde5d60ce63564e0430a5dd4581bb2054169711e38f56f3843476086a",
+        "size_in_bytes": 6308
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_hyperparser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9fb9939622aea749d0c2fd6270e619ab2c9571b0e58f5892eb0de2adf85e0ea7",
+        "sha256_in_prefix": "9fb9939622aea749d0c2fd6270e619ab2c9571b0e58f5892eb0de2adf85e0ea7",
+        "size_in_bytes": 7352
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_iomenu.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fdf3ed7a0d789bdc43e4b44f50c3f75a9a09077e9eed7e00451f5b0de6ce3caa",
+        "sha256_in_prefix": "fdf3ed7a0d789bdc43e4b44f50c3f75a9a09077e9eed7e00451f5b0de6ce3caa",
+        "size_in_bytes": 2887
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_macosx.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "670e6ed8044e31980c102f2c5b502a8a5e487276ebe48a3fe7c5229b7f816647",
+        "sha256_in_prefix": "670e6ed8044e31980c102f2c5b502a8a5e487276ebe48a3fe7c5229b7f816647",
+        "size_in_bytes": 4253
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_mainmenu.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "684cadcb5616d121f2534b95e5da3cf16170be65d7577c5040009b4b9278f2f0",
+        "sha256_in_prefix": "684cadcb5616d121f2534b95e5da3cf16170be65d7577c5040009b4b9278f2f0",
+        "size_in_bytes": 1814
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_multicall.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "892d97874e0ee73827d9e2fc7e9c63619a33c53b73417856196f15a53759789a",
+        "sha256_in_prefix": "892d97874e0ee73827d9e2fc7e9c63619a33c53b73417856196f15a53759789a",
+        "size_in_bytes": 1754
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_outwin.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f3b6f523c6fb9b110921c19764d143cd73ed0e477b42bc92c0719da2839cd92e",
+        "sha256_in_prefix": "f3b6f523c6fb9b110921c19764d143cd73ed0e477b42bc92c0719da2839cd92e",
+        "size_in_bytes": 5307
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_parenmatch.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "58754b2aa6bcfa1e1c40374ca090f1b866094fc7015a995ecb50d255890ddfc5",
+        "sha256_in_prefix": "58754b2aa6bcfa1e1c40374ca090f1b866094fc7015a995ecb50d255890ddfc5",
+        "size_in_bytes": 3846
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_pathbrowser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b7e749694981e6d120b145cf15fbcf1cf09ef16884395b3fa82b94d1fb159a3a",
+        "sha256_in_prefix": "b7e749694981e6d120b145cf15fbcf1cf09ef16884395b3fa82b94d1fb159a3a",
+        "size_in_bytes": 3312
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_percolator.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0782522cb8607f346b6a69c5f6f2c2c159dd5618dc2f551367cbe3bea4b56db7",
+        "sha256_in_prefix": "0782522cb8607f346b6a69c5f6f2c2c159dd5618dc2f551367cbe3bea4b56db7",
+        "size_in_bytes": 4890
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_pyparse.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0ef63a1cf84ec83b8b5b2b93bdc453b069c082526ccfa81a5dc288f940012920",
+        "sha256_in_prefix": "0ef63a1cf84ec83b8b5b2b93bdc453b069c082526ccfa81a5dc288f940012920",
+        "size_in_bytes": 13629
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_pyshell.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3b286172a75bef0a1878d7a205e28e4ca37a88640116db0a8e21f1235137da51",
+        "sha256_in_prefix": "3b286172a75bef0a1878d7a205e28e4ca37a88640116db0a8e21f1235137da51",
+        "size_in_bytes": 2184
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_query.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7751ae4d90f87fd923069cae8bdce1a28fa425038086244f76bf0caf13ce9575",
+        "sha256_in_prefix": "7751ae4d90f87fd923069cae8bdce1a28fa425038086244f76bf0caf13ce9575",
+        "size_in_bytes": 19913
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_redirector.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1ba365d83080fdb6d675eb3cf99a2b7fdcc28a0c23cb4c4cb2c30e25ad7425cc",
+        "sha256_in_prefix": "1ba365d83080fdb6d675eb3cf99a2b7fdcc28a0c23cb4c4cb2c30e25ad7425cc",
+        "size_in_bytes": 5117
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_replace.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dc99ffe1dd386f6cb87a5652a832f0856dba6735b300f66705a83ec35bdb5d86",
+        "sha256_in_prefix": "dc99ffe1dd386f6cb87a5652a832f0856dba6735b300f66705a83ec35bdb5d86",
+        "size_in_bytes": 6842
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_rpc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "97fd3ae091c3609016c4ac0902619d0a11d63ecf6fb1abaaa961b1ab9adf38e7",
+        "sha256_in_prefix": "97fd3ae091c3609016c4ac0902619d0a11d63ecf6fb1abaaa961b1ab9adf38e7",
+        "size_in_bytes": 1622
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_run.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "af343bc87f58fd583264b32bb25d8906f2ebcba188c3e711865534b3a00fc2dd",
+        "sha256_in_prefix": "af343bc87f58fd583264b32bb25d8906f2ebcba188c3e711865534b3a00fc2dd",
+        "size_in_bytes": 13794
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_runscript.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "311ce8fa601d23a9c6536fede84f9e540f278b9a5a3829ea256ffe883f35a545",
+        "sha256_in_prefix": "311ce8fa601d23a9c6536fede84f9e540f278b9a5a3829ea256ffe883f35a545",
+        "size_in_bytes": 1310
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_scrolledlist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4268fea8658b2cf4a31bdc540f5df6b3c489bf76d5cff839f5598171f99f4d05",
+        "sha256_in_prefix": "4268fea8658b2cf4a31bdc540f5df6b3c489bf76d5cff839f5598171f99f4d05",
+        "size_in_bytes": 1076
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_search.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d81b2acc89d768a0ee3cb413e6c460cb192174a30e4e1d75682b219abc1f6e0b",
+        "sha256_in_prefix": "d81b2acc89d768a0ee3cb413e6c460cb192174a30e4e1d75682b219abc1f6e0b",
+        "size_in_bytes": 2467
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_searchbase.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8b0a1e80b5381c4d3c0e42fd663c625f6b4be95db81913af8a8d2f4f08c5178c",
+        "sha256_in_prefix": "8b0a1e80b5381c4d3c0e42fd663c625f6b4be95db81913af8a8d2f4f08c5178c",
+        "size_in_bytes": 5306
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_searchengine.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e0c40663c76b9605b30dafc1c1425898e961eb7f1bdc600443a7bb364ea4528a",
+        "sha256_in_prefix": "e0c40663c76b9605b30dafc1c1425898e961eb7f1bdc600443a7bb364ea4528a",
+        "size_in_bytes": 9769
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_sidebar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9a4fc2c5c4683cb8d5a614ef2f6281fad369f27344fd27df79a71c62692d50e1",
+        "sha256_in_prefix": "9a4fc2c5c4683cb8d5a614ef2f6281fad369f27344fd27df79a71c62692d50e1",
+        "size_in_bytes": 11902
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_squeezer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "26f16134870cfd13add389e0d616663be52fd81f9a1ff29267906468886ad197",
+        "sha256_in_prefix": "26f16134870cfd13add389e0d616663be52fd81f9a1ff29267906468886ad197",
+        "size_in_bytes": 15995
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_stackviewer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a18f8223c25b1f991766d5ed792f88f7fb042d18b70382f4f37500866d639778",
+        "sha256_in_prefix": "a18f8223c25b1f991766d5ed792f88f7fb042d18b70382f4f37500866d639778",
+        "size_in_bytes": 1529
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_statusbar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8b09d85f1c67e798e5e2ccd7213813bfc1282d70634877ece1d68660d1179672",
+        "sha256_in_prefix": "8b09d85f1c67e798e5e2ccd7213813bfc1282d70634877ece1d68660d1179672",
+        "size_in_bytes": 1558
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_text.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "79f9a8ebcb55027282f58de6747d44c2207d17ee973a1d308be2053466822c62",
+        "sha256_in_prefix": "79f9a8ebcb55027282f58de6747d44c2207d17ee973a1d308be2053466822c62",
+        "size_in_bytes": 6244
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_textview.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8dc6cb5656430eb5828b759d4a7807a93e5cbd2c25b4b38803cd81e4c1138094",
+        "sha256_in_prefix": "8dc6cb5656430eb5828b759d4a7807a93e5cbd2c25b4b38803cd81e4c1138094",
+        "size_in_bytes": 9160
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_tooltip.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "27e21baae3cfbb2f0dcd7fc51a18169489a048a7446adbc8843f5ce8117d6660",
+        "sha256_in_prefix": "27e21baae3cfbb2f0dcd7fc51a18169489a048a7446adbc8843f5ce8117d6660",
+        "size_in_bytes": 5184
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_tree.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f3a133bca6af75fd702ca05ecb1746e00bb2a483b1027a806c6c0fe2174b1af5",
+        "sha256_in_prefix": "f3a133bca6af75fd702ca05ecb1746e00bb2a483b1027a806c6c0fe2174b1af5",
+        "size_in_bytes": 2661
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_undo.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e3e0d1cbbb5120bda43adeb792a9df5ae9b29671e6754e504d7020e114d12e12",
+        "sha256_in_prefix": "e3e0d1cbbb5120bda43adeb792a9df5ae9b29671e6754e504d7020e114d12e12",
+        "size_in_bytes": 4136
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "98828a96c4cbf64a1d2419751cdff512a681d0677e818bafeb9ca7c22a550f69",
+        "sha256_in_prefix": "98828a96c4cbf64a1d2419751cdff512a681d0677e818bafeb9ca7c22a550f69",
+        "size_in_bytes": 672
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_warning.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ed09db820e31c790e1820b076a1ad7dfb5448a843a5ce3da3df7e7f920e9bfc9",
+        "sha256_in_prefix": "ed09db820e31c790e1820b076a1ad7dfb5448a843a5ce3da3df7e7f920e9bfc9",
+        "size_in_bytes": 2642
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_window.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "957cb3f6b297c02abaf3ef807feb9392ec469777cf91ca33b7c7bb755137c736",
+        "sha256_in_prefix": "957cb3f6b297c02abaf3ef807feb9392ec469777cf91ca33b7c7bb755137c736",
+        "size_in_bytes": 1609
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_zoomheight.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e32cc43033588d98c35772ac84b77006b2a1682ffcefa8354d8a74b00b5487a1",
+        "sha256_in_prefix": "e32cc43033588d98c35772ac84b77006b2a1682ffcefa8354d8a74b00b5487a1",
+        "size_in_bytes": 1500
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/__pycache__/test_zzdummy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2c3e384048c41751bbdfe240277ac1a6083d3eef64768f225c19371df9f79092",
+        "sha256_in_prefix": "2c3e384048c41751bbdfe240277ac1a6083d3eef64768f225c19371df9f79092",
+        "size_in_bytes": 4486
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/example_noext",
+        "path_type": "hardlink",
+        "sha256": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe",
+        "sha256_in_prefix": "526edff5d21fd1f1421f5ab6a706cb51732edcae235b9895f93a8f46e25505fe",
+        "size_in_bytes": 68
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/example_stub.pyi",
+        "path_type": "hardlink",
+        "sha256": "5546cf759222c0f6ad74c740c6bf9558a731ef75d57988a5233beed40aa3a28b",
+        "sha256_in_prefix": "5546cf759222c0f6ad74c740c6bf9558a731ef75d57988a5233beed40aa3a28b",
+        "size_in_bytes": 87
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/htest.py",
+        "path_type": "hardlink",
+        "sha256": "48e03aae8546b4e1579edf21b47bd9835f11a6b097752d8226ca515c887e77e0",
+        "sha256_in_prefix": "48e03aae8546b4e1579edf21b47bd9835f11a6b097752d8226ca515c887e77e0",
+        "size_in_bytes": 15199
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/mock_idle.py",
+        "path_type": "hardlink",
+        "sha256": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4",
+        "sha256_in_prefix": "637d74d26089c582fb784c2920f5bcb41e5b1fc8b9e0931ddc1cc8d92becbff4",
+        "size_in_bytes": 1943
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/mock_tk.py",
+        "path_type": "hardlink",
+        "sha256": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7",
+        "sha256_in_prefix": "7d60a26e82fd0469a95e02c2adda6607363a51ab67d5851cc323a58a595f74a7",
+        "size_in_bytes": 11693
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/template.py",
+        "path_type": "hardlink",
+        "sha256": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8",
+        "sha256_in_prefix": "43421286ad234a4240f8d4bc09f67bb58da0bf9d9b07bf93010989ef2c17f2f8",
+        "size_in_bytes": 642
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_autocomplete.py",
+        "path_type": "hardlink",
+        "sha256": "fe590922db07a3d718241385c14ed103ae3b45edf9bffe3c49bd78a677f439a1",
+        "sha256_in_prefix": "fe590922db07a3d718241385c14ed103ae3b45edf9bffe3c49bd78a677f439a1",
+        "size_in_bytes": 10904
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_autocomplete_w.py",
+        "path_type": "hardlink",
+        "sha256": "30ab335b5312af5ca57b26945c7297bec89f31e90d70e7c8cb0a2283599ab40f",
+        "sha256_in_prefix": "30ab335b5312af5ca57b26945c7297bec89f31e90d70e7c8cb0a2283599ab40f",
+        "size_in_bytes": 709
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_autoexpand.py",
+        "path_type": "hardlink",
+        "sha256": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243",
+        "sha256_in_prefix": "85f913f8cbd5dfd5d52d3b7d00eedec231ec3e4ee7d117db4a2bb714eb1a7243",
+        "size_in_bytes": 4638
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_browser.py",
+        "path_type": "hardlink",
+        "sha256": "b23c6e6874f1d4d6acead3a3600dd64773e741f06d3641c5f29af92bfaa7b90f",
+        "sha256_in_prefix": "b23c6e6874f1d4d6acead3a3600dd64773e741f06d3641c5f29af92bfaa7b90f",
+        "size_in_bytes": 7963
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_calltip.py",
+        "path_type": "hardlink",
+        "sha256": "8fd994aed39f1b89a05137e2bf6e53401685ec408d5c424e267ff635bf8a6cdb",
+        "sha256_in_prefix": "8fd994aed39f1b89a05137e2bf6e53401685ec408d5c424e267ff635bf8a6cdb",
+        "size_in_bytes": 13194
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_calltip_w.py",
+        "path_type": "hardlink",
+        "sha256": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004",
+        "sha256_in_prefix": "7462c048c689f82c3ae6b5782a18776762f88055b80ae77a92243b6c0606e004",
+        "size_in_bytes": 686
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_codecontext.py",
+        "path_type": "hardlink",
+        "sha256": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0",
+        "sha256_in_prefix": "84e6b890b22b2abcc0865c691162b93c6ffb9b4e17f05011bdaffa770a52fcf0",
+        "size_in_bytes": 16082
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_colorizer.py",
+        "path_type": "hardlink",
+        "sha256": "aa4bb34f3f98e039f730033cf89d343281d41410af1c31d73ac5b291a59be1f3",
+        "sha256_in_prefix": "aa4bb34f3f98e039f730033cf89d343281d41410af1c31d73ac5b291a59be1f3",
+        "size_in_bytes": 15017
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_config.py",
+        "path_type": "hardlink",
+        "sha256": "98f856694b51330c729d4a87f5efd4c6c805db01edcea77d80b17f89d71bc054",
+        "sha256_in_prefix": "98f856694b51330c729d4a87f5efd4c6c805db01edcea77d80b17f89d71bc054",
+        "size_in_bytes": 32046
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_config_key.py",
+        "path_type": "hardlink",
+        "sha256": "4c90f5869eea7116af135636529b262c7d7b8a4db4ccbf379945e3d7c90532dd",
+        "sha256_in_prefix": "4c90f5869eea7116af135636529b262c7d7b8a4db4ccbf379945e3d7c90532dd",
+        "size_in_bytes": 9708
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_configdialog.py",
+        "path_type": "hardlink",
+        "sha256": "520f4fc6cb52d8a6159565de605c3de008b8115da3f8db74cf2f9d466e288a54",
+        "sha256_in_prefix": "520f4fc6cb52d8a6159565de605c3de008b8115da3f8db74cf2f9d466e288a54",
+        "size_in_bytes": 55344
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_debugger.py",
+        "path_type": "hardlink",
+        "sha256": "1881dcf94b0a44fe355f2acabfe25d8d67871402bbc19aaab37c6ff955575f1d",
+        "sha256_in_prefix": "1881dcf94b0a44fe355f2acabfe25d8d67871402bbc19aaab37c6ff955575f1d",
+        "size_in_bytes": 571
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_debugger_r.py",
+        "path_type": "hardlink",
+        "sha256": "dbbc8f9c2f1b0f37625f2dc25d7322945ba4144708c9d17da256a6236acd6aac",
+        "sha256_in_prefix": "dbbc8f9c2f1b0f37625f2dc25d7322945ba4144708c9d17da256a6236acd6aac",
+        "size_in_bytes": 1009
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_debugobj.py",
+        "path_type": "hardlink",
+        "sha256": "e35a9f45b223d5c7e7f3bbfd8bc6495b1156c40b0ce3747ade0aed7b41aa23ac",
+        "sha256_in_prefix": "e35a9f45b223d5c7e7f3bbfd8bc6495b1156c40b0ce3747ade0aed7b41aa23ac",
+        "size_in_bytes": 1561
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_debugobj_r.py",
+        "path_type": "hardlink",
+        "sha256": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb",
+        "sha256_in_prefix": "22d74368ba175175b9c14315f9d82fd7ddde60ae93d2e5572e9a647de7e869eb",
+        "size_in_bytes": 545
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_delegator.py",
+        "path_type": "hardlink",
+        "sha256": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca",
+        "sha256_in_prefix": "559d39df8c1ff38d177943f245b87f5379ee5ea93399fd6b5f7bfa882e6ed8ca",
+        "size_in_bytes": 1567
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_editmenu.py",
+        "path_type": "hardlink",
+        "sha256": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a",
+        "sha256_in_prefix": "ed3800137d48ffcf86ecb71afe5a24cd9ed381571f23036438ba8a97f502326a",
+        "size_in_bytes": 2564
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_editor.py",
+        "path_type": "hardlink",
+        "sha256": "281f8597aef644910a5aad17cba6303e296378113f0ce24e5ea7346015e395ce",
+        "sha256_in_prefix": "281f8597aef644910a5aad17cba6303e296378113f0ce24e5ea7346015e395ce",
+        "size_in_bytes": 7523
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_filelist.py",
+        "path_type": "hardlink",
+        "sha256": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c",
+        "sha256_in_prefix": "d4cea5fdba68fb9e361541820d44eed003c317f4ef14bb9df3406b8d2c53ef7c",
+        "size_in_bytes": 795
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_format.py",
+        "path_type": "hardlink",
+        "sha256": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6",
+        "sha256_in_prefix": "b356a2a8f5fe14c39c6af73623484df4ed930cc16ef4605f3b04fd9b618867a6",
+        "size_in_bytes": 23610
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_grep.py",
+        "path_type": "hardlink",
+        "sha256": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c",
+        "sha256_in_prefix": "ca64de882b5608e016b7df8f739089c9f262643bce09979b76399cc4be1ea12c",
+        "size_in_bytes": 5072
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_help.py",
+        "path_type": "hardlink",
+        "sha256": "e39288f4326136cadb4fab81fe31223187136bc3d9bdf65a9d67fd152e50a6e9",
+        "sha256_in_prefix": "e39288f4326136cadb4fab81fe31223187136bc3d9bdf65a9d67fd152e50a6e9",
+        "size_in_bytes": 849
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_help_about.py",
+        "path_type": "hardlink",
+        "sha256": "d0268651a7c7b4aec72da3e81c45b8488d33de3459300b7226dccc31ad956309",
+        "sha256_in_prefix": "d0268651a7c7b4aec72da3e81c45b8488d33de3459300b7226dccc31ad956309",
+        "size_in_bytes": 5919
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_history.py",
+        "path_type": "hardlink",
+        "sha256": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3",
+        "sha256_in_prefix": "6319fe7810ed91786b503de80701a291a4f9abe54c9e101c19c0917b709e62f3",
+        "size_in_bytes": 5517
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_hyperparser.py",
+        "path_type": "hardlink",
+        "sha256": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183",
+        "sha256_in_prefix": "cd2fbc788d4d75b514e53951dc90d00d41a8a87baad31bc1e380b7449bfcf183",
+        "size_in_bytes": 9082
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_iomenu.py",
+        "path_type": "hardlink",
+        "sha256": "c26448d7b1cf7efa1fe2ccb61c7136baa2c566a879500d616b51e9d1bfa92125",
+        "sha256_in_prefix": "c26448d7b1cf7efa1fe2ccb61c7136baa2c566a879500d616b51e9d1bfa92125",
+        "size_in_bytes": 1908
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_macosx.py",
+        "path_type": "hardlink",
+        "sha256": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368",
+        "sha256_in_prefix": "975e48ab453711c5072988e2e66a7fe51e716ac64e494f022a5ff82781ccd368",
+        "size_in_bytes": 3444
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_mainmenu.py",
+        "path_type": "hardlink",
+        "sha256": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5",
+        "sha256_in_prefix": "faa064ffd9c8e30b1205e46bb4ede816c74b7948cfa34c7795ed19c35eac10d5",
+        "size_in_bytes": 1638
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_multicall.py",
+        "path_type": "hardlink",
+        "sha256": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f",
+        "sha256_in_prefix": "1bfb51912275d8e346dce0a40ab84316b15e3f142e66529a8c9cfd52210c1a1f",
+        "size_in_bytes": 1317
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_outwin.py",
+        "path_type": "hardlink",
+        "sha256": "255ae7e3271491d7bacb0cc32d0cc9b88c689c58d8543dad1bafec569109c7c6",
+        "sha256_in_prefix": "255ae7e3271491d7bacb0cc32d0cc9b88c689c58d8543dad1bafec569109c7c6",
+        "size_in_bytes": 5422
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_parenmatch.py",
+        "path_type": "hardlink",
+        "sha256": "64f4c6e0f47de1e833d5228fb36c72292280094b6c774cac52f3707c41bb6f16",
+        "sha256_in_prefix": "64f4c6e0f47de1e833d5228fb36c72292280094b6c774cac52f3707c41bb6f16",
+        "size_in_bytes": 3550
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_pathbrowser.py",
+        "path_type": "hardlink",
+        "sha256": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e",
+        "sha256_in_prefix": "a7d9c5085ff5c64232897f6ee0a09258a41a35f153f47ff0f3b8fa97ec67be9e",
+        "size_in_bytes": 2422
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_percolator.py",
+        "path_type": "hardlink",
+        "sha256": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b",
+        "sha256_in_prefix": "133b134a46b23cf2c635be3116415fd388e3a1c1581bf1a77d7f7f0aff3a725b",
+        "size_in_bytes": 4065
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_pyparse.py",
+        "path_type": "hardlink",
+        "sha256": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35",
+        "sha256_in_prefix": "8f386a9f535369afb495322e104077c66c5a3abb91917ec69f868b405120cf35",
+        "size_in_bytes": 19365
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_pyshell.py",
+        "path_type": "hardlink",
+        "sha256": "ebdd6bb219641820ade89944b438bff446bbb89423e36139dc41e016d94c933b",
+        "sha256_in_prefix": "ebdd6bb219641820ade89944b438bff446bbb89423e36139dc41e016d94c933b",
+        "size_in_bytes": 2171
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_query.py",
+        "path_type": "hardlink",
+        "sha256": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3",
+        "sha256_in_prefix": "632c2dc13a158a5902e5b758166151ffa377db7f5a0c368bc3b0741a237876c3",
+        "size_in_bytes": 15454
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_redirector.py",
+        "path_type": "hardlink",
+        "sha256": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c",
+        "sha256_in_prefix": "517c1fe16da359e01f3cdfdf3f7aead4283e8b8e1107522b72f59d4c4f3ade4c",
+        "size_in_bytes": 4176
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_replace.py",
+        "path_type": "hardlink",
+        "sha256": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1",
+        "sha256_in_prefix": "321333b3eaad9ecbf633186bc625d4a60c4c736def0fa00665add2ab899eecb1",
+        "size_in_bytes": 8299
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_rpc.py",
+        "path_type": "hardlink",
+        "sha256": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823",
+        "sha256_in_prefix": "1e2d997f442002389b3dadb47ed8134947c664a32ef637f43afdcbd1b5c13823",
+        "size_in_bytes": 805
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_run.py",
+        "path_type": "hardlink",
+        "sha256": "6cf27c336850035741d9dfc9f82dead5cc80781b078e50de397aba9fa049cb2b",
+        "sha256_in_prefix": "6cf27c336850035741d9dfc9f82dead5cc80781b078e50de397aba9fa049cb2b",
+        "size_in_bytes": 13983
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_runscript.py",
+        "path_type": "hardlink",
+        "sha256": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61",
+        "sha256_in_prefix": "4264a834dc230d397725f398d905d0746321d543c56644e5c89af59fe3fedb61",
+        "size_in_bytes": 777
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_scrolledlist.py",
+        "path_type": "hardlink",
+        "sha256": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a",
+        "sha256_in_prefix": "a84ec601c8786daf0564e978c97c0e14095c23f9a08bb64950f9cb541b074b3a",
+        "size_in_bytes": 496
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_search.py",
+        "path_type": "hardlink",
+        "sha256": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b",
+        "sha256_in_prefix": "c0550b241c99a566f61929515ca97aedf99f73568df3dfe93078ed22cb54892b",
+        "size_in_bytes": 2459
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_searchbase.py",
+        "path_type": "hardlink",
+        "sha256": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b",
+        "sha256_in_prefix": "2b8550dd411b75c6152c4da90843e1221094400080f9a1752e383d0b776f775b",
+        "size_in_bytes": 5691
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_searchengine.py",
+        "path_type": "hardlink",
+        "sha256": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97",
+        "sha256_in_prefix": "519ddd5633eb8732539594f79ed21a6544f65e599a0d5c8c84db3a488ccdad97",
+        "size_in_bytes": 11588
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_sidebar.py",
+        "path_type": "hardlink",
+        "sha256": "e16f5f55d909fef8e3b59f84f0add8ca6c54d884343e983a482f1e9c46b4b596",
+        "sha256_in_prefix": "e16f5f55d909fef8e3b59f84f0add8ca6c54d884343e983a482f1e9c46b4b596",
+        "size_in_bytes": 13231
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_squeezer.py",
+        "path_type": "hardlink",
+        "sha256": "fe5fa3776ddae32db2e150293eedfd996f1dcd09c353a2d5f232b165c231f79e",
+        "sha256_in_prefix": "fe5fa3776ddae32db2e150293eedfd996f1dcd09c353a2d5f232b165c231f79e",
+        "size_in_bytes": 20108
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_stackviewer.py",
+        "path_type": "hardlink",
+        "sha256": "483502cfbfce0ac87198cfd6d0ec7e5eec68834042ed949875730a35764c83ca",
+        "sha256_in_prefix": "483502cfbfce0ac87198cfd6d0ec7e5eec68834042ed949875730a35764c83ca",
+        "size_in_bytes": 1206
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_statusbar.py",
+        "path_type": "hardlink",
+        "sha256": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02",
+        "sha256_in_prefix": "0e9b262b9ad0046cbb0af1101a651fcb88cd1cba38e474b863abbb074b260a02",
+        "size_in_bytes": 1133
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_text.py",
+        "path_type": "hardlink",
+        "sha256": "96437194c674ad031297b060e590387062fa29455c2c7131ed9c7eaeb644db7b",
+        "sha256_in_prefix": "96437194c674ad031297b060e590387062fa29455c2c7131ed9c7eaeb644db7b",
+        "size_in_bytes": 6978
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_textview.py",
+        "path_type": "hardlink",
+        "sha256": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533",
+        "sha256_in_prefix": "e45b199106608c7c981c149d3b4ccf092e7a2e7e9430cc76887cd769b9aaf533",
+        "size_in_bytes": 7364
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_tooltip.py",
+        "path_type": "hardlink",
+        "sha256": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153",
+        "sha256_in_prefix": "b9a82e57761bbca3d4e07193652e8294895765092ef8a651f4dcf63acec7f153",
+        "size_in_bytes": 5385
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_tree.py",
+        "path_type": "hardlink",
+        "sha256": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166",
+        "sha256_in_prefix": "62ae68d64105485107e8173f94ce09739f276004bc8fa65efa5add2c6188e166",
+        "size_in_bytes": 1752
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_undo.py",
+        "path_type": "hardlink",
+        "sha256": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e",
+        "sha256_in_prefix": "c5178b2dd77d794938fa52adce719d4948a92ba1a689068cec1fb6888d033e0e",
+        "size_in_bytes": 4228
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_util.py",
+        "path_type": "hardlink",
+        "sha256": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5",
+        "sha256_in_prefix": "300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5",
+        "size_in_bytes": 308
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_warning.py",
+        "path_type": "hardlink",
+        "sha256": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193",
+        "sha256_in_prefix": "d1efc442b3fb93de89fb0988c73f8536fc5099afb761d2b69ec101c239c8c193",
+        "size_in_bytes": 2740
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_window.py",
+        "path_type": "hardlink",
+        "sha256": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6",
+        "sha256_in_prefix": "336f2b6994f5aacca9689f32249db20a8dac36934314b7d5ba391d94169d63c6",
+        "size_in_bytes": 1075
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_zoomheight.py",
+        "path_type": "hardlink",
+        "sha256": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44",
+        "sha256_in_prefix": "6300aa47014a5c2dfc9bc0d6c3fb234dff4e4b60a6527d4cdfbb8c416f99df44",
+        "size_in_bytes": 999
+      },
+      {
+        "_path": "Lib/idlelib/idle_test/test_zzdummy.py",
+        "path_type": "hardlink",
+        "sha256": "b36aa909cd737b2ab252f6735c083928283633063e742e130550e6ba37247057",
+        "sha256_in_prefix": "b36aa909cd737b2ab252f6735c083928283633063e742e130550e6ba37247057",
+        "size_in_bytes": 4457
+      },
+      {
+        "_path": "Lib/idlelib/iomenu.py",
+        "path_type": "hardlink",
+        "sha256": "058157c474314a2c6e95b6a4ca7fe36fc9ff1c4528694fa8881ae95339b916ec",
+        "sha256_in_prefix": "058157c474314a2c6e95b6a4ca7fe36fc9ff1c4528694fa8881ae95339b916ec",
+        "size_in_bytes": 15832
+      },
+      {
+        "_path": "Lib/idlelib/macosx.py",
+        "path_type": "hardlink",
+        "sha256": "fe034060194d98567fa9f1cce67488fc6d13d9385bd4a070b4f9cf352f178faa",
+        "sha256_in_prefix": "fe034060194d98567fa9f1cce67488fc6d13d9385bd4a070b4f9cf352f178faa",
+        "size_in_bytes": 9663
+      },
+      {
+        "_path": "Lib/idlelib/mainmenu.py",
+        "path_type": "hardlink",
+        "sha256": "4043c70f2394019c86793250dbb21492e68e7e88b171a419afc0119a5332d50a",
+        "sha256_in_prefix": "4043c70f2394019c86793250dbb21492e68e7e88b171a419afc0119a5332d50a",
+        "size_in_bytes": 3930
+      },
+      {
+        "_path": "Lib/idlelib/multicall.py",
+        "path_type": "hardlink",
+        "sha256": "277f16699b17c3fd176c1b259959ed235bb9bb59d54731203c9c33c2e0e43172",
+        "sha256_in_prefix": "277f16699b17c3fd176c1b259959ed235bb9bb59d54731203c9c33c2e0e43172",
+        "size_in_bytes": 18648
+      },
+      {
+        "_path": "Lib/idlelib/outwin.py",
+        "path_type": "hardlink",
+        "sha256": "39a6018927b4543c3fcbd857f3bd1de7097c8f185bdee8f3373c7c3c4da70e84",
+        "sha256_in_prefix": "39a6018927b4543c3fcbd857f3bd1de7097c8f185bdee8f3373c7c3c4da70e84",
+        "size_in_bytes": 5709
+      },
+      {
+        "_path": "Lib/idlelib/parenmatch.py",
+        "path_type": "hardlink",
+        "sha256": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287",
+        "sha256_in_prefix": "f122e13c385a135cbbbe8b1d87efeed43ddd3e0be9ddd8aa24b267b61fac4287",
+        "size_in_bytes": 7204
+      },
+      {
+        "_path": "Lib/idlelib/pathbrowser.py",
+        "path_type": "hardlink",
+        "sha256": "0d0bf5c92b0f2a5fe25ddf95729f6cba8a9ac48c7c0d1c2fdd7a7532586f2ea4",
+        "sha256_in_prefix": "0d0bf5c92b0f2a5fe25ddf95729f6cba8a9ac48c7c0d1c2fdd7a7532586f2ea4",
+        "size_in_bytes": 3193
+      },
+      {
+        "_path": "Lib/idlelib/percolator.py",
+        "path_type": "hardlink",
+        "sha256": "6be7d55a95c96f5bdffc7869acfea19c33c62a23ef9515d4f2f9e5b93b38b905",
+        "sha256_in_prefix": "6be7d55a95c96f5bdffc7869acfea19c33c62a23ef9515d4f2f9e5b93b38b905",
+        "size_in_bytes": 3130
+      },
+      {
+        "_path": "Lib/idlelib/pyparse.py",
+        "path_type": "hardlink",
+        "sha256": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648",
+        "sha256_in_prefix": "21c6bf43370998d5a5a6670f7b13409335e9a2c1a350ed586bbe63be5f226648",
+        "size_in_bytes": 19864
+      },
+      {
+        "_path": "Lib/idlelib/pyshell.py",
+        "path_type": "hardlink",
+        "sha256": "8fefee372e0d32800ddc9479438d4bf4476f0d864a1b63542fd7182c2420c984",
+        "sha256_in_prefix": "8fefee372e0d32800ddc9479438d4bf4476f0d864a1b63542fd7182c2420c984",
+        "size_in_bytes": 57605
+      },
+      {
+        "_path": "Lib/idlelib/query.py",
+        "path_type": "hardlink",
+        "sha256": "a8984d77e39ffa556b775cb915fa38d4d8de8fb7afa20c10e47ff62c2f191b29",
+        "sha256_in_prefix": "a8984d77e39ffa556b775cb915fa38d4d8de8fb7afa20c10e47ff62c2f191b29",
+        "size_in_bytes": 15075
+      },
+      {
+        "_path": "Lib/idlelib/redirector.py",
+        "path_type": "hardlink",
+        "sha256": "f9bd3a01148a0d6627692f4ef22f93361cd19e4e279510c45a522ef10ff6650d",
+        "sha256_in_prefix": "f9bd3a01148a0d6627692f4ef22f93361cd19e4e279510c45a522ef10ff6650d",
+        "size_in_bytes": 6875
+      },
+      {
+        "_path": "Lib/idlelib/replace.py",
+        "path_type": "hardlink",
+        "sha256": "14cc63d77057a20a35e235ce12e2ff851e3ddff3fd8e3497dfa8d76215fcc917",
+        "sha256_in_prefix": "14cc63d77057a20a35e235ce12e2ff851e3ddff3fd8e3497dfa8d76215fcc917",
+        "size_in_bytes": 9799
+      },
+      {
+        "_path": "Lib/idlelib/rpc.py",
+        "path_type": "hardlink",
+        "sha256": "b2c2cfc240e07330f7c5901feb7853734845d2a26ee01ab0282d0ddd29f163d1",
+        "sha256_in_prefix": "b2c2cfc240e07330f7c5901feb7853734845d2a26ee01ab0282d0ddd29f163d1",
+        "size_in_bytes": 21076
+      },
+      {
+        "_path": "Lib/idlelib/run.py",
+        "path_type": "hardlink",
+        "sha256": "950382e4f9b3f90e94029d42967e58a827456cefdd332512b89a0e9a66fb8fb9",
+        "sha256_in_prefix": "950382e4f9b3f90e94029d42967e58a827456cefdd332512b89a0e9a66fb8fb9",
+        "size_in_bytes": 21046
+      },
+      {
+        "_path": "Lib/idlelib/runscript.py",
+        "path_type": "hardlink",
+        "sha256": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe",
+        "sha256_in_prefix": "b92740fddc7b1d603b1736a135bd15518081f20c0db1e1a779cab715ee9120fe",
+        "size_in_bytes": 8273
+      },
+      {
+        "_path": "Lib/idlelib/scrolledlist.py",
+        "path_type": "hardlink",
+        "sha256": "fd08b385ac576e43fa8dc10efb644425b9847d6b70b19f0b2ef484d7c0776f82",
+        "sha256_in_prefix": "fd08b385ac576e43fa8dc10efb644425b9847d6b70b19f0b2ef484d7c0776f82",
+        "size_in_bytes": 4465
+      },
+      {
+        "_path": "Lib/idlelib/search.py",
+        "path_type": "hardlink",
+        "sha256": "85db5685f1d80d59ff013e045a963057e03af2588994b9805806385309847fe6",
+        "sha256_in_prefix": "85db5685f1d80d59ff013e045a963057e03af2588994b9805806385309847fe6",
+        "size_in_bytes": 5566
+      },
+      {
+        "_path": "Lib/idlelib/searchbase.py",
+        "path_type": "hardlink",
+        "sha256": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc",
+        "sha256_in_prefix": "5e13c99d9f264166d9204eeff0492d43d03f2afd8f66494b3e110d7665ab29cc",
+        "size_in_bytes": 7856
+      },
+      {
+        "_path": "Lib/idlelib/searchengine.py",
+        "path_type": "hardlink",
+        "sha256": "7981c39d8eef04d1afe30cbf47661b31504d85530550377d38df3d8d61c775af",
+        "sha256_in_prefix": "7981c39d8eef04d1afe30cbf47661b31504d85530550377d38df3d8d61c775af",
+        "size_in_bytes": 7362
+      },
+      {
+        "_path": "Lib/idlelib/sidebar.py",
+        "path_type": "hardlink",
+        "sha256": "b09cc00aa56e0ef2fd7222620a03202eb00e35d31c39a0c236be7aaac6dc5b22",
+        "sha256_in_prefix": "b09cc00aa56e0ef2fd7222620a03202eb00e35d31c39a0c236be7aaac6dc5b22",
+        "size_in_bytes": 13585
+      },
+      {
+        "_path": "Lib/idlelib/squeezer.py",
+        "path_type": "hardlink",
+        "sha256": "bc5dce511181c72b336363bd7e0b59e7a1a40959e8718ec58aed9604c82675da",
+        "sha256_in_prefix": "bc5dce511181c72b336363bd7e0b59e7a1a40959e8718ec58aed9604c82675da",
+        "size_in_bytes": 12825
+      },
+      {
+        "_path": "Lib/idlelib/stackviewer.py",
+        "path_type": "hardlink",
+        "sha256": "926a667aa9936ec65cd80b2650d2f0f3434c2ee54f0be91939259add06ef7fd4",
+        "sha256_in_prefix": "926a667aa9936ec65cd80b2650d2f0f3434c2ee54f0be91939259add06ef7fd4",
+        "size_in_bytes": 4454
+      },
+      {
+        "_path": "Lib/idlelib/statusbar.py",
+        "path_type": "hardlink",
+        "sha256": "7847dfee4e6e1a025ae8b5bfe7d4503d86cf731653dc452804429c3b96c709eb",
+        "sha256_in_prefix": "7847dfee4e6e1a025ae8b5bfe7d4503d86cf731653dc452804429c3b96c709eb",
+        "size_in_bytes": 1472
+      },
+      {
+        "_path": "Lib/idlelib/textview.py",
+        "path_type": "hardlink",
+        "sha256": "7351da2057dfbfb1523cb1f80bb4965bdb7d9f4271a557571e511f373688d269",
+        "sha256_in_prefix": "7351da2057dfbfb1523cb1f80bb4965bdb7d9f4271a557571e511f373688d269",
+        "size_in_bytes": 6813
+      },
+      {
+        "_path": "Lib/idlelib/tooltip.py",
+        "path_type": "hardlink",
+        "sha256": "dff2c8d2225e5737ffbc37e8ec7c49ece4fd6bfbd6e910e4e79ffc01b91f7145",
+        "sha256_in_prefix": "dff2c8d2225e5737ffbc37e8ec7c49ece4fd6bfbd6e910e4e79ffc01b91f7145",
+        "size_in_bytes": 6557
+      },
+      {
+        "_path": "Lib/idlelib/tree.py",
+        "path_type": "hardlink",
+        "sha256": "2daa545a8e3c1988ef653a2f4f42e6338f793a245cb1e3d82226159ff9a08347",
+        "sha256_in_prefix": "2daa545a8e3c1988ef653a2f4f42e6338f793a245cb1e3d82226159ff9a08347",
+        "size_in_bytes": 16370
+      },
+      {
+        "_path": "Lib/idlelib/undo.py",
+        "path_type": "hardlink",
+        "sha256": "915f353f4eb7052a48cc63f202816bdd3345a03598fb871ff5966304f255d739",
+        "sha256_in_prefix": "915f353f4eb7052a48cc63f202816bdd3345a03598fb871ff5966304f255d739",
+        "size_in_bytes": 11046
+      },
+      {
+        "_path": "Lib/idlelib/util.py",
+        "path_type": "hardlink",
+        "sha256": "9aa32fd58162d796d46657ec6172dfca991a0403af846480e1346bee5765777c",
+        "sha256_in_prefix": "9aa32fd58162d796d46657ec6172dfca991a0403af846480e1346bee5765777c",
+        "size_in_bytes": 721
+      },
+      {
+        "_path": "Lib/idlelib/window.py",
+        "path_type": "hardlink",
+        "sha256": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd",
+        "sha256_in_prefix": "ca31d8c01c9b468fcad0a4e529c8e205c1e4ecf30520545db654d466bd7158bd",
+        "size_in_bytes": 2616
+      },
+      {
+        "_path": "Lib/idlelib/zoomheight.py",
+        "path_type": "hardlink",
+        "sha256": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd",
+        "sha256_in_prefix": "5f6ff83cb0df3ee5e7d997ffe23efb341b994bfbaf00b79a4832d54231a095dd",
+        "size_in_bytes": 4203
+      },
+      {
+        "_path": "Lib/idlelib/zzdummy.py",
+        "path_type": "hardlink",
+        "sha256": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945",
+        "sha256_in_prefix": "5e248f0ea4f35052d23bb2c43564aa567b8cebaf91fd63ba0be8fef2f4167945",
+        "size_in_bytes": 2005
+      },
+      {
+        "_path": "Lib/imaplib.py",
+        "path_type": "hardlink",
+        "sha256": "a1b7c66898289b909cba5ccc054b9985ef946bfbaca3514df55318419f157605",
+        "sha256_in_prefix": "a1b7c66898289b909cba5ccc054b9985ef946bfbaca3514df55318419f157605",
+        "size_in_bytes": 54904
+      },
+      {
+        "_path": "Lib/imghdr.py",
+        "path_type": "hardlink",
+        "sha256": "653ad8d50f1c3cb3a0cc4d2876c60aaa40732c42779dea2e1db547639d27b085",
+        "sha256_in_prefix": "653ad8d50f1c3cb3a0cc4d2876c60aaa40732c42779dea2e1db547639d27b085",
+        "size_in_bytes": 3808
+      },
+      {
+        "_path": "Lib/imp.py",
+        "path_type": "hardlink",
+        "sha256": "3f68bb8f699b1fe5d813bea965590f7385ac47ca0bbab6cd459697dbb3344a70",
+        "sha256_in_prefix": "3f68bb8f699b1fe5d813bea965590f7385ac47ca0bbab6cd459697dbb3344a70",
+        "size_in_bytes": 10536
+      },
+      {
+        "_path": "Lib/importlib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "45421c08a03062ba41e37e484cb0e4d8474be13c2a34806cb5b63c9edcb94a10",
+        "sha256_in_prefix": "45421c08a03062ba41e37e484cb0e4d8474be13c2a34806cb5b63c9edcb94a10",
+        "size_in_bytes": 6061
+      },
+      {
+        "_path": "Lib/importlib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0d9a87248e2eae013d8d5a199e08f42ac4887bd6442c20fadee2c1cbc98d42e8",
+        "sha256_in_prefix": "0d9a87248e2eae013d8d5a199e08f42ac4887bd6442c20fadee2c1cbc98d42e8",
+        "size_in_bytes": 3816
+      },
+      {
+        "_path": "Lib/importlib/__pycache__/_bootstrap.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d148a996b3e7405cbe81d0a0ded07b071e8e0e611bafc072585061515c7c5ef8",
+        "sha256_in_prefix": "d148a996b3e7405cbe81d0a0ded07b071e8e0e611bafc072585061515c7c5ef8",
+        "size_in_bytes": 28951
+      },
+      {
+        "_path": "Lib/importlib/__pycache__/_bootstrap_external.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d9c2e98f8975121748b2d44b04b8c3ba924992e581a490af68d55708a8d92b7f",
+        "sha256_in_prefix": "d9c2e98f8975121748b2d44b04b8c3ba924992e581a490af68d55708a8d92b7f",
+        "size_in_bytes": 45263
+      },
+      {
+        "_path": "Lib/importlib/__pycache__/_common.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f02ec1d1e9a1d5cb943b428e0745027b1c3a8d578338a132c05343f4c160e39b",
+        "sha256_in_prefix": "f02ec1d1e9a1d5cb943b428e0745027b1c3a8d578338a132c05343f4c160e39b",
+        "size_in_bytes": 1682
+      },
+      {
+        "_path": "Lib/importlib/__pycache__/abc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "632dbbd3576293919df20d0dc5bef292efdcfb93a9948ef343c87a3f5d6d7df4",
+        "sha256_in_prefix": "632dbbd3576293919df20d0dc5bef292efdcfb93a9948ef343c87a3f5d6d7df4",
+        "size_in_bytes": 16800
+      },
+      {
+        "_path": "Lib/importlib/__pycache__/machinery.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0930ab0e1882ce0fba9ec742666854e21f6aefc1313c8d526330c475fa393f8b",
+        "sha256_in_prefix": "0930ab0e1882ce0fba9ec742666854e21f6aefc1313c8d526330c475fa393f8b",
+        "size_in_bytes": 947
+      },
+      {
+        "_path": "Lib/importlib/__pycache__/metadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a29cdacd1a8696805657d1e9731f9051214fc4e92823221223e382330131b21c",
+        "sha256_in_prefix": "a29cdacd1a8696805657d1e9731f9051214fc4e92823221223e382330131b21c",
+        "size_in_bytes": 22157
+      },
+      {
+        "_path": "Lib/importlib/__pycache__/resources.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ce6e7620a28110ffeef4ab4d61dcf3b12bcf3e86a85f5d76b42f64f964a2fd29",
+        "sha256_in_prefix": "ce6e7620a28110ffeef4ab4d61dcf3b12bcf3e86a85f5d76b42f64f964a2fd29",
+        "size_in_bytes": 6374
+      },
+      {
+        "_path": "Lib/importlib/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f91f0c51cf751989e8d087d8a7d38144e984d78d0c70e514013381c030a4000a",
+        "sha256_in_prefix": "f91f0c51cf751989e8d087d8a7d38144e984d78d0c70e514013381c030a4000a",
+        "size_in_bytes": 9305
+      },
+      {
+        "_path": "Lib/importlib/_bootstrap.py",
+        "path_type": "hardlink",
+        "sha256": "dccbc1da2f9e922b2faab3b1db5543f6898539b3603b406a88b03a287d76a62e",
+        "sha256_in_prefix": "dccbc1da2f9e922b2faab3b1db5543f6898539b3603b406a88b03a287d76a62e",
+        "size_in_bytes": 40322
+      },
+      {
+        "_path": "Lib/importlib/_bootstrap_external.py",
+        "path_type": "hardlink",
+        "sha256": "63ab92f8f4b2123a3493f2d825db46cfdd2e54332c3c8a85feb9b94406824809",
+        "sha256_in_prefix": "63ab92f8f4b2123a3493f2d825db46cfdd2e54332c3c8a85feb9b94406824809",
+        "size_in_bytes": 64947
+      },
+      {
+        "_path": "Lib/importlib/_common.py",
+        "path_type": "hardlink",
+        "sha256": "68c01949e387c156b264a8b82da669028f07c99f935281ccc6d6766f04117782",
+        "sha256_in_prefix": "68c01949e387c156b264a8b82da669028f07c99f935281ccc6d6766f04117782",
+        "size_in_bytes": 1497
+      },
+      {
+        "_path": "Lib/importlib/abc.py",
+        "path_type": "hardlink",
+        "sha256": "bb1ede7cadc644812085a65ce8de61cfd4984544d49d6893e80d8506cf29dc41",
+        "sha256_in_prefix": "bb1ede7cadc644812085a65ce8de61cfd4984544d49d6893e80d8506cf29dc41",
+        "size_in_bytes": 14924
+      },
+      {
+        "_path": "Lib/importlib/machinery.py",
+        "path_type": "hardlink",
+        "sha256": "d8675d9b5553ae4ce0a01005bc47a199b9167ef2c4217a4bbda8f457170aae8b",
+        "sha256_in_prefix": "d8675d9b5553ae4ce0a01005bc47a199b9167ef2c4217a4bbda8f457170aae8b",
+        "size_in_bytes": 844
+      },
+      {
+        "_path": "Lib/importlib/metadata.py",
+        "path_type": "hardlink",
+        "sha256": "5701e0bf3d1c7642aeb6299353b8e57280eae3356482c18204942a7ba799adbf",
+        "sha256_in_prefix": "5701e0bf3d1c7642aeb6299353b8e57280eae3356482c18204942a7ba799adbf",
+        "size_in_bytes": 18750
+      },
+      {
+        "_path": "Lib/importlib/resources.py",
+        "path_type": "hardlink",
+        "sha256": "07d8a5220197b92ae106f4f5b0e798c671d16f0bc03e9f6372f4c122b0dd314b",
+        "sha256_in_prefix": "07d8a5220197b92ae106f4f5b0e798c671d16f0bc03e9f6372f4c122b0dd314b",
+        "size_in_bytes": 7209
+      },
+      {
+        "_path": "Lib/importlib/util.py",
+        "path_type": "hardlink",
+        "sha256": "b6a71515fade6516217f7c7d78ab927fde6530a145543c39ce03d1577f668fb7",
+        "sha256_in_prefix": "b6a71515fade6516217f7c7d78ab927fde6530a145543c39ce03d1577f668fb7",
+        "size_in_bytes": 11321
+      },
+      {
+        "_path": "Lib/inspect.py",
+        "path_type": "hardlink",
+        "sha256": "17e544a5878cd0faf92f38c99cb0a0fd849ee3480a2e76beab754915a742cfcc",
+        "sha256_in_prefix": "17e544a5878cd0faf92f38c99cb0a0fd849ee3480a2e76beab754915a742cfcc",
+        "size_in_bytes": 118235
+      },
+      {
+        "_path": "Lib/io.py",
+        "path_type": "hardlink",
+        "sha256": "01907eff5e1a17d37e967b4d6d1bd2230e03d30f56cc1a1384a14dd77be5ff60",
+        "sha256_in_prefix": "01907eff5e1a17d37e967b4d6d1bd2230e03d30f56cc1a1384a14dd77be5ff60",
+        "size_in_bytes": 3541
+      },
+      {
+        "_path": "Lib/ipaddress.py",
+        "path_type": "hardlink",
+        "sha256": "3393f129e36c62b7e58fb6ad33f852f68458ef135f9c50f9e25b132b4d288311",
+        "sha256_in_prefix": "3393f129e36c62b7e58fb6ad33f852f68458ef135f9c50f9e25b132b4d288311",
+        "size_in_bytes": 78634
+      },
+      {
+        "_path": "Lib/json/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "2c36f543113566dbbd04ee4326b0d0a57ec2ab32c6340d7c84719c18e6696856",
+        "sha256_in_prefix": "2c36f543113566dbbd04ee4326b0d0a57ec2ab32c6340d7c84719c18e6696856",
+        "size_in_bytes": 14019
+      },
+      {
+        "_path": "Lib/json/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5c9f38921d720fc9407fa55ec599660f151f19cd10e4e2a78de98ebe8df8e745",
+        "sha256_in_prefix": "5c9f38921d720fc9407fa55ec599660f151f19cd10e4e2a78de98ebe8df8e745",
+        "size_in_bytes": 12278
+      },
+      {
+        "_path": "Lib/json/__pycache__/decoder.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a51140cde06f66f2173467bd6e86151aaef01680300fef67763c801b2dfeb6c6",
+        "sha256_in_prefix": "a51140cde06f66f2173467bd6e86151aaef01680300fef67763c801b2dfeb6c6",
+        "size_in_bytes": 9791
+      },
+      {
+        "_path": "Lib/json/__pycache__/encoder.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "943ab12aae0661e34b5a8e4e447aec874a6332d59966826b371eacfa458db9dc",
+        "sha256_in_prefix": "943ab12aae0661e34b5a8e4e447aec874a6332d59966826b371eacfa458db9dc",
+        "size_in_bytes": 11115
+      },
+      {
+        "_path": "Lib/json/__pycache__/scanner.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "43e1e7bfd17af3a645da0184dbd240c4adc6ce841d908694424f47e57b084d7a",
+        "sha256_in_prefix": "43e1e7bfd17af3a645da0184dbd240c4adc6ce841d908694424f47e57b084d7a",
+        "size_in_bytes": 1936
+      },
+      {
+        "_path": "Lib/json/__pycache__/tool.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d8d0b3c24440f2a0211ddd94917f0bf7ee5ac38d10522ba9300a5854916bf14",
+        "sha256_in_prefix": "2d8d0b3c24440f2a0211ddd94917f0bf7ee5ac38d10522ba9300a5854916bf14",
+        "size_in_bytes": 2792
+      },
+      {
+        "_path": "Lib/json/decoder.py",
+        "path_type": "hardlink",
+        "sha256": "079f7a25863c18fc9a9abc59735d684535b9deaafc08acda416997784b78e9c5",
+        "sha256_in_prefix": "079f7a25863c18fc9a9abc59735d684535b9deaafc08acda416997784b78e9c5",
+        "size_in_bytes": 12472
+      },
+      {
+        "_path": "Lib/json/encoder.py",
+        "path_type": "hardlink",
+        "sha256": "721a182f3473f01f4dc9ce61d6dbc1ad1f9db0138cd93e4121e0ac9173b91a27",
+        "sha256_in_prefix": "721a182f3473f01f4dc9ce61d6dbc1ad1f9db0138cd93e4121e0ac9173b91a27",
+        "size_in_bytes": 16073
+      },
+      {
+        "_path": "Lib/json/scanner.py",
+        "path_type": "hardlink",
+        "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08",
+        "sha256_in_prefix": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08",
+        "size_in_bytes": 2425
+      },
+      {
+        "_path": "Lib/json/tool.py",
+        "path_type": "hardlink",
+        "sha256": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77",
+        "sha256_in_prefix": "d5174b728b376a12cff3f17472d6b9b609c1d3926f7ee02d74d60c80afd60c77",
+        "size_in_bytes": 3339
+      },
+      {
+        "_path": "Lib/keyword.py",
+        "path_type": "hardlink",
+        "sha256": "22997a4c432a03c3ec9b91d0c20be3d59648fd22c6f1251c6d071fd3f32b7308",
+        "sha256_in_prefix": "22997a4c432a03c3ec9b91d0c20be3d59648fd22c6f1251c6d071fd3f32b7308",
+        "size_in_bytes": 1047
+      },
+      {
+        "_path": "Lib/lib2to3/Grammar.txt",
+        "path_type": "hardlink",
+        "sha256": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6",
+        "sha256_in_prefix": "508e62e787dd756eb0a4eb1b8d128320ca02cd246ab14cc8ce0a476dc88cc5b6",
+        "size_in_bytes": 8696
+      },
+      {
+        "_path": "Lib/lib2to3/Grammar3.9.21.final.0.pickle",
+        "path_type": "hardlink",
+        "sha256": "97c8ed74d091fcfd23498029bb819c29d096c3dcb1326edee5dfb0591ade2e4b",
+        "sha256_in_prefix": "97c8ed74d091fcfd23498029bb819c29d096c3dcb1326edee5dfb0591ade2e4b",
+        "size_in_bytes": 15313
+      },
+      {
+        "_path": "Lib/lib2to3/PatternGrammar.txt",
+        "path_type": "hardlink",
+        "sha256": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3",
+        "sha256_in_prefix": "ee5ba5db3b6722a0e2fbe2560ebc1c883e72328ef9c3b4da1c7c5d1cc649bce3",
+        "size_in_bytes": 793
+      },
+      {
+        "_path": "Lib/lib2to3/PatternGrammar3.9.21.final.0.pickle",
+        "path_type": "hardlink",
+        "sha256": "36ee934395b9209737b13893ddaff05fad8e239c2fdfac29d401d3fceeb30768",
+        "sha256_in_prefix": "36ee934395b9209737b13893ddaff05fad8e239c2fdfac29d401d3fceeb30768",
+        "size_in_bytes": 1225
+      },
+      {
+        "_path": "Lib/lib2to3/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "f4d8715dcaeb8183319e613f00574170b06ca2ff7af34e62d6e869919fc129d7",
+        "sha256_in_prefix": "f4d8715dcaeb8183319e613f00574170b06ca2ff7af34e62d6e869919fc129d7",
+        "size_in_bytes": 163
+      },
+      {
+        "_path": "Lib/lib2to3/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707",
+        "sha256_in_prefix": "c7b09f90e66dea194ad63dc02c6425dff977d16f1f21a157b7475905c219a707",
+        "size_in_bytes": 67
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "37615408d510dae54109f00eefab0b0e8d8dbec489e3bc7fc4176799b8dd60d2",
+        "sha256_in_prefix": "37615408d510dae54109f00eefab0b0e8d8dbec489e3bc7fc4176799b8dd60d2",
+        "size_in_bytes": 285
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bcd86a44a60ce9efef2333030b44de47029ec2dab6bc404aca85052da986eee8",
+        "sha256_in_prefix": "bcd86a44a60ce9efef2333030b44de47029ec2dab6bc404aca85052da986eee8",
+        "size_in_bytes": 198
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/btm_matcher.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a18f33824051d9c5a1915877f801b54553f0fd332a70f8b208c1085099bf2da6",
+        "sha256_in_prefix": "a18f33824051d9c5a1915877f801b54553f0fd332a70f8b208c1085099bf2da6",
+        "size_in_bytes": 4860
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/btm_utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "84ae5eb5f2e2ce58e5d0449dab4e6c2a1068f75991b38e83ace09c9291a1a559",
+        "sha256_in_prefix": "84ae5eb5f2e2ce58e5d0449dab4e6c2a1068f75991b38e83ace09c9291a1a559",
+        "size_in_bytes": 6131
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/fixer_base.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "56216de700520d1cfa4d91781ce7af32f83c34a5695a186c54d15dcc2f84fcf3",
+        "sha256_in_prefix": "56216de700520d1cfa4d91781ce7af32f83c34a5695a186c54d15dcc2f84fcf3",
+        "size_in_bytes": 6238
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/fixer_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ae630ab08b6b9fc86391991d6fdb2d106fbfc4958cfb65a89a3fe29eb718d9d1",
+        "sha256_in_prefix": "ae630ab08b6b9fc86391991d6fdb2d106fbfc4958cfb65a89a3fe29eb718d9d1",
+        "size_in_bytes": 12153
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/main.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "84200fd8f89cfcf6fc6f3530bde0f906b0644187a54ce717ce228403866bbf86",
+        "sha256_in_prefix": "84200fd8f89cfcf6fc6f3530bde0f906b0644187a54ce717ce228403866bbf86",
+        "size_in_bytes": 8672
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/patcomp.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "41d9c5f423d9dfb1ee16a865e6c436af858efd1e1ff206cb5307221722589bbf",
+        "sha256_in_prefix": "41d9c5f423d9dfb1ee16a865e6c436af858efd1e1ff206cb5307221722589bbf",
+        "size_in_bytes": 5588
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/pygram.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1d863b0b44a7fb1c45427c529837087ab755a8ea804aa6b89b54b69ef1993e0f",
+        "sha256_in_prefix": "1d863b0b44a7fb1c45427c529837087ab755a8ea804aa6b89b54b69ef1993e0f",
+        "size_in_bytes": 1245
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/pytree.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "409d45d5e1d62871f37cbecc4ab60af3236561bb80967da49ed5f03756d45b49",
+        "sha256_in_prefix": "409d45d5e1d62871f37cbecc4ab60af3236561bb80967da49ed5f03756d45b49",
+        "size_in_bytes": 24278
+      },
+      {
+        "_path": "Lib/lib2to3/__pycache__/refactor.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "585b4d1c96b6cf64887defabc730ecd733aa6ee911f63206169b30e554953d44",
+        "sha256_in_prefix": "585b4d1c96b6cf64887defabc730ecd733aa6ee911f63206169b30e554953d44",
+        "size_in_bytes": 20626
+      },
+      {
+        "_path": "Lib/lib2to3/btm_matcher.py",
+        "path_type": "hardlink",
+        "sha256": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d",
+        "sha256_in_prefix": "a1aa5d35558acf4b6016054963285cb145f97a764926bea07cbd674563f3248d",
+        "size_in_bytes": 6623
+      },
+      {
+        "_path": "Lib/lib2to3/btm_utils.py",
+        "path_type": "hardlink",
+        "sha256": "79d210510630052adafcc7c4ad8cf16acd2fd8e9adb46deea952cd81bfbea661",
+        "sha256_in_prefix": "79d210510630052adafcc7c4ad8cf16acd2fd8e9adb46deea952cd81bfbea661",
+        "size_in_bytes": 9966
+      },
+      {
+        "_path": "Lib/lib2to3/fixer_base.py",
+        "path_type": "hardlink",
+        "sha256": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a",
+        "sha256_in_prefix": "c795a53ca849c42212c8ec33a74284e0377df852eb4ea599aba62d5af1df282a",
+        "size_in_bytes": 6690
+      },
+      {
+        "_path": "Lib/lib2to3/fixer_util.py",
+        "path_type": "hardlink",
+        "sha256": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608",
+        "sha256_in_prefix": "306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608",
+        "size_in_bytes": 15206
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9",
+        "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9",
+        "size_in_bytes": 47
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2323cef0221f30158719bf37c3d58f61a9892b8854208da6d863efda36ed8535",
+        "sha256_in_prefix": "2323cef0221f30158719bf37c3d58f61a9892b8854208da6d863efda36ed8535",
+        "size_in_bytes": 120
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_apply.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "701ddf55fc2ce22f4ad259256e75908e3d20a259b674c10d295a89a4087a0cac",
+        "sha256_in_prefix": "701ddf55fc2ce22f4ad259256e75908e3d20a259b674c10d295a89a4087a0cac",
+        "size_in_bytes": 1642
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_asserts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f1b3cf499c8aa516dec84e97e7eea2f15c0bf94d7c7c8a271f53db1c1333a7cf",
+        "sha256_in_prefix": "f1b3cf499c8aa516dec84e97e7eea2f15c0bf94d7c7c8a271f53db1c1333a7cf",
+        "size_in_bytes": 1257
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_basestring.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "229c64a9f648dc1200a83f606020c16a2df1a960d85baae4d78ee75e8eeda4dc",
+        "sha256_in_prefix": "229c64a9f648dc1200a83f606020c16a2df1a960d85baae4d78ee75e8eeda4dc",
+        "size_in_bytes": 641
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_buffer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e758023ba5af806b9757247f64c35da5c23ea309e296f11f0c728944e3db3ecd",
+        "sha256_in_prefix": "e758023ba5af806b9757247f64c35da5c23ea309e296f11f0c728944e3db3ecd",
+        "size_in_bytes": 786
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_dict.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e54c468927f727f32e15c7f58c65e812adb5d0a22cafcbe96ba6716fe23c2801",
+        "sha256_in_prefix": "e54c468927f727f32e15c7f58c65e812adb5d0a22cafcbe96ba6716fe23c2801",
+        "size_in_bytes": 3289
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_except.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "652f669b6fbdd0170612045b0a4a09e5ab25f1b81f22bf39f7cd768be9950376",
+        "sha256_in_prefix": "652f669b6fbdd0170612045b0a4a09e5ab25f1b81f22bf39f7cd768be9950376",
+        "size_in_bytes": 2784
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_exec.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "69379c85c4c55fd4df3a9e75c1a33257adfac111a92731c299a04fca0f8b316d",
+        "sha256_in_prefix": "69379c85c4c55fd4df3a9e75c1a33257adfac111a92731c299a04fca0f8b316d",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_execfile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b73046279ff844db31b48df0958da13a5cd8e7053a42e55676ae193aa80997d3",
+        "sha256_in_prefix": "b73046279ff844db31b48df0958da13a5cd8e7053a42e55676ae193aa80997d3",
+        "size_in_bytes": 1659
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_exitfunc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ee81aeda45ea44e7120c3861a8ca1e3152cce80afff8a1186c118c4774bc128e",
+        "sha256_in_prefix": "ee81aeda45ea44e7120c3861a8ca1e3152cce80afff8a1186c118c4774bc128e",
+        "size_in_bytes": 2284
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_filter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8598486acb33166017278f15e5204671d8200c096671db5a218c1e824210ee4e",
+        "sha256_in_prefix": "8598486acb33166017278f15e5204671d8200c096671db5a218c1e824210ee4e",
+        "size_in_bytes": 2420
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_funcattrs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4b71d6f95d2a700933db3e5a90adad1e51301ec4352669dd2ee73c25632d75d8",
+        "sha256_in_prefix": "4b71d6f95d2a700933db3e5a90adad1e51301ec4352669dd2ee73c25632d75d8",
+        "size_in_bytes": 954
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_future.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0b874805970506541e014316b496231dd337fb8a7f67d24e0abde26eb5d2d440",
+        "sha256_in_prefix": "0b874805970506541e014316b496231dd337fb8a7f67d24e0abde26eb5d2d440",
+        "size_in_bytes": 762
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_getcwdu.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c9567d2699e07700a34d1f310b9afc77474697befe1fb85e566d5231e36ef8b7",
+        "sha256_in_prefix": "c9567d2699e07700a34d1f310b9afc77474697befe1fb85e566d5231e36ef8b7",
+        "size_in_bytes": 766
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_has_key.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "301a848a041a6abc2dc0ef47ec016c8e4743c40e989f09983a4511bab8c5d185",
+        "sha256_in_prefix": "301a848a041a6abc2dc0ef47ec016c8e4743c40e989f09983a4511bab8c5d185",
+        "size_in_bytes": 2881
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_idioms.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bfd0edfa9200d473fb5dd78237519a45a67ebbb1eecc8e609547893f26f12eae",
+        "sha256_in_prefix": "bfd0edfa9200d473fb5dd78237519a45a67ebbb1eecc8e609547893f26f12eae",
+        "size_in_bytes": 3883
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_import.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9b5a1dde1edf81477023150707ee1ba2e1ae62d6ab360972eab24021e1a61d09",
+        "sha256_in_prefix": "9b5a1dde1edf81477023150707ee1ba2e1ae62d6ab360972eab24021e1a61d09",
+        "size_in_bytes": 2761
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_imports.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b5330506c7c04cc97775dad256faa4aafa37f1bbf79abbf782a1e1e47d3881a6",
+        "sha256_in_prefix": "b5330506c7c04cc97775dad256faa4aafa37f1bbf79abbf782a1e1e47d3881a6",
+        "size_in_bytes": 4365
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_imports2.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ad5c8d762a57a65159e7a1e5be459de5acbf0feb65a838b3e11e1abc9fb16f6b",
+        "sha256_in_prefix": "ad5c8d762a57a65159e7a1e5be459de5acbf0feb65a838b3e11e1abc9fb16f6b",
+        "size_in_bytes": 524
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_input.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2fe6c0a873853908edba77684225c2d77564e82c7d88109f005de5e5a8b6e192",
+        "sha256_in_prefix": "2fe6c0a873853908edba77684225c2d77564e82c7d88109f005de5e5a8b6e192",
+        "size_in_bytes": 928
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_intern.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2f44d1d146992690d6a1fd8681c417c5b45bc6e9489aa8ec3c2cf4b347f32443",
+        "sha256_in_prefix": "2f44d1d146992690d6a1fd8681c417c5b45bc6e9489aa8ec3c2cf4b347f32443",
+        "size_in_bytes": 1112
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_isinstance.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9763be6d3739c6e5ee061acb84a47e0c95376066c1b6236c2e49b20f7ab5f2a1",
+        "sha256_in_prefix": "9763be6d3739c6e5ee061acb84a47e0c95376066c1b6236c2e49b20f7ab5f2a1",
+        "size_in_bytes": 1529
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_itertools.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8e9c95fc8250473bb12741e7cab787e0959b275037277ba312064bf864fe9aeb",
+        "sha256_in_prefix": "8e9c95fc8250473bb12741e7cab787e0959b275037277ba312064bf864fe9aeb",
+        "size_in_bytes": 1528
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_itertools_imports.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c1f805ac104c5d73099d808151077391323fa4a10a8136b7ad05f415d744124d",
+        "sha256_in_prefix": "c1f805ac104c5d73099d808151077391323fa4a10a8136b7ad05f415d744124d",
+        "size_in_bytes": 1540
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_long.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "30bbeb9a9a2bea28ab998ea87ddf47e935c960b5a9b357e5e6dcb729db6f7630",
+        "sha256_in_prefix": "30bbeb9a9a2bea28ab998ea87ddf47e935c960b5a9b357e5e6dcb729db6f7630",
+        "size_in_bytes": 683
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_map.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d634fde641086328abd0815921dcc651c0dcd481af3199b0e35337aea1e572e4",
+        "sha256_in_prefix": "d634fde641086328abd0815921dcc651c0dcd481af3199b0e35337aea1e572e4",
+        "size_in_bytes": 3075
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_metaclass.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fe1d5547526d338c5dc87b8f5a0e9555f853b45948d50ea263a85ea967999973",
+        "sha256_in_prefix": "fe1d5547526d338c5dc87b8f5a0e9555f853b45948d50ea263a85ea967999973",
+        "size_in_bytes": 5309
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_methodattrs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1d45bee27c7429dc62188b5773fd9f7ab63e97b06da22a192d4972a3eeceb883",
+        "sha256_in_prefix": "1d45bee27c7429dc62188b5773fd9f7ab63e97b06da22a192d4972a3eeceb883",
+        "size_in_bytes": 916
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_ne.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "363dddbbcdf228fed7f6b048db407aa3b910221c3035a9aefd6ba2a42dc738dc",
+        "sha256_in_prefix": "363dddbbcdf228fed7f6b048db407aa3b910221c3035a9aefd6ba2a42dc738dc",
+        "size_in_bytes": 789
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_next.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "99fd7b57dca1548d34004ce7f4d71886a8e5463532227e75932a2089c740f13b",
+        "sha256_in_prefix": "99fd7b57dca1548d34004ce7f4d71886a8e5463532227e75932a2089c740f13b",
+        "size_in_bytes": 3033
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_nonzero.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd14a5f3c0b15dc747b26be515cde2a7fe2441a257337ecd7325265da488291a",
+        "sha256_in_prefix": "dd14a5f3c0b15dc747b26be515cde2a7fe2441a257337ecd7325265da488291a",
+        "size_in_bytes": 901
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_numliterals.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "03975105484895619353197e74db01b899babd0cc453fe7a9f89ab245f4e0d6d",
+        "sha256_in_prefix": "03975105484895619353197e74db01b899babd0cc453fe7a9f89ab245f4e0d6d",
+        "size_in_bytes": 1001
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_operator.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e583747ce571c95cdfe4258b00d494120061ec46bcadf45dd894ebcf2ccc45d9",
+        "sha256_in_prefix": "e583747ce571c95cdfe4258b00d494120061ec46bcadf45dd894ebcf2ccc45d9",
+        "size_in_bytes": 4198
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_paren.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "528a7b7243f0e3d7b1904353ba3efb81858ba365a2aa8194059ce06c03adbbca",
+        "sha256_in_prefix": "528a7b7243f0e3d7b1904353ba3efb81858ba365a2aa8194059ce06c03adbbca",
+        "size_in_bytes": 1367
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_print.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f69561d79a0e9360ac8381a7c70ea64bbe95e8ff0a683af9a439fb55824c4dd8",
+        "sha256_in_prefix": "f69561d79a0e9360ac8381a7c70ea64bbe95e8ff0a683af9a439fb55824c4dd8",
+        "size_in_bytes": 2301
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_raise.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8c93723141c0b9dd6aa991aaf08224d72878256c70ef7a4db2e8f01132652a67",
+        "sha256_in_prefix": "8c93723141c0b9dd6aa991aaf08224d72878256c70ef7a4db2e8f01132652a67",
+        "size_in_bytes": 2227
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_raw_input.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "684dc947ec93a9a20d6b3882d253b0930b01ea2e6c64efef21a43850b669be01",
+        "sha256_in_prefix": "684dc947ec93a9a20d6b3882d253b0930b01ea2e6c64efef21a43850b669be01",
+        "size_in_bytes": 773
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_reduce.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "53c033ac653b5bbcfab7a3534d8fd0ad7cce0a25fe43630daaff54f629f8a123",
+        "sha256_in_prefix": "53c033ac653b5bbcfab7a3534d8fd0ad7cce0a25fe43630daaff54f629f8a123",
+        "size_in_bytes": 1106
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_reload.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "90e44933b42f4a126e7615e4c57a605bc8bd0689e81ba33301d84a79aced9591",
+        "sha256_in_prefix": "90e44933b42f4a126e7615e4c57a605bc8bd0689e81ba33301d84a79aced9591",
+        "size_in_bytes": 1124
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_renames.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f1ab6184050ae010ccb1f600bf9b222cf3244964392e04304f7ceb78d9a735ad",
+        "sha256_in_prefix": "f1ab6184050ae010ccb1f600bf9b222cf3244964392e04304f7ceb78d9a735ad",
+        "size_in_bytes": 1981
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_repr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e079a3b662659b78d43c6f902e1c343a5719d3a80514b5c11b5f9770fc28b339",
+        "sha256_in_prefix": "e079a3b662659b78d43c6f902e1c343a5719d3a80514b5c11b5f9770fc28b339",
+        "size_in_bytes": 823
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_set_literal.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c6abcda9c909743e9e315898a859f6ee08c880a9b4deac248252f7fb341de94c",
+        "sha256_in_prefix": "c6abcda9c909743e9e315898a859f6ee08c880a9b4deac248252f7fb341de94c",
+        "size_in_bytes": 1657
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_standarderror.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6fe1d1cb3e2bf89003e8733ae05156fdff7568e3d926109d804b83ae3f6a234c",
+        "sha256_in_prefix": "6fe1d1cb3e2bf89003e8733ae05156fdff7568e3d926109d804b83ae3f6a234c",
+        "size_in_bytes": 698
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_sys_exc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3c0a6279a99ab51da42e739f9bcaf09752aa5df5036aa50c52b750e94cd0f01d",
+        "sha256_in_prefix": "3c0a6279a99ab51da42e739f9bcaf09752aa5df5036aa50c52b750e94cd0f01d",
+        "size_in_bytes": 1385
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_throw.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5dc91386b5eb094c56a52ad77b33f9b8ad314524a28595db1adfd846d1278717",
+        "sha256_in_prefix": "5dc91386b5eb094c56a52ad77b33f9b8ad314524a28595db1adfd846d1278717",
+        "size_in_bytes": 1782
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_tuple_params.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ae77358f158c6f30ca649dcf1b8287792e6c028347976fe8cd5d3d89609d585a",
+        "sha256_in_prefix": "ae77358f158c6f30ca649dcf1b8287792e6c028347976fe8cd5d3d89609d585a",
+        "size_in_bytes": 4559
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_types.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "81edd475ada69af07464cf6984a050366cbd315fc5ef60188a6f0ed51f0e0fc3",
+        "sha256_in_prefix": "81edd475ada69af07464cf6984a050366cbd315fc5ef60188a6f0ed51f0e0fc3",
+        "size_in_bytes": 1811
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_unicode.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b27df53fe0d1cd159effa1b05a69555de5e1eb6fc44eb8defff713adb7f04864",
+        "sha256_in_prefix": "b27df53fe0d1cd159effa1b05a69555de5e1eb6fc44eb8defff713adb7f04864",
+        "size_in_bytes": 1527
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_urllib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b33f72ba0fdae6fcba71bf8ef5f1a3929a0a4faac68cdd85932681788cc5f466",
+        "sha256_in_prefix": "b33f72ba0fdae6fcba71bf8ef5f1a3929a0a4faac68cdd85932681788cc5f466",
+        "size_in_bytes": 5838
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_ws_comma.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3f951cc48648e6efd9e796ca8243f0898b1d551a6258de4fe6e911919bca3330",
+        "sha256_in_prefix": "3f951cc48648e6efd9e796ca8243f0898b1d551a6258de4fe6e911919bca3330",
+        "size_in_bytes": 1097
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_xrange.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "525ffea10cfcef8ea1d84234c612eaaf68c14629b9459ad80c68f580f184233e",
+        "sha256_in_prefix": "525ffea10cfcef8ea1d84234c612eaaf68c14629b9459ad80c68f580f184233e",
+        "size_in_bytes": 2507
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_xreadlines.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8a1d2284099a60dfc2cc709c5d4fe5be77148781d0aaf05783e1e5735b7c501d",
+        "sha256_in_prefix": "8a1d2284099a60dfc2cc709c5d4fe5be77148781d0aaf05783e1e5735b7c501d",
+        "size_in_bytes": 1097
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/__pycache__/fix_zip.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "efcf9ef75e11183a81a58aa9385e9149057776b09092ef03be90f767e4251e8c",
+        "sha256_in_prefix": "efcf9ef75e11183a81a58aa9385e9149057776b09092ef03be90f767e4251e8c",
+        "size_in_bytes": 1557
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_apply.py",
+        "path_type": "hardlink",
+        "sha256": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a",
+        "sha256_in_prefix": "b5171e32758a78450854f40867775d4aca58665bc920ebece04fcfcc153af02a",
+        "size_in_bytes": 2346
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_asserts.py",
+        "path_type": "hardlink",
+        "sha256": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd",
+        "sha256_in_prefix": "4c77972812cb5ec0a72afbce3e1d618c27ef7b239329c5c952c2bcbe77dba5dd",
+        "size_in_bytes": 984
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_basestring.py",
+        "path_type": "hardlink",
+        "sha256": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f",
+        "sha256_in_prefix": "d041443d6499a735bb78fec9da1bf33b3d034b5192c98bc273b16a44692fc88f",
+        "size_in_bytes": 320
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_buffer.py",
+        "path_type": "hardlink",
+        "sha256": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883",
+        "sha256_in_prefix": "2da37b49c30d6a0b4db43146ebb4ac8e5ffcb9814816b4742e464cb856977883",
+        "size_in_bytes": 590
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_dict.py",
+        "path_type": "hardlink",
+        "sha256": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea",
+        "sha256_in_prefix": "38f460596ebfb64046aab3d9a65935bd4c76a470118fb7d10a088dc0ecdc53ea",
+        "size_in_bytes": 3760
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_except.py",
+        "path_type": "hardlink",
+        "sha256": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651",
+        "sha256_in_prefix": "7ff6f560c3c3d7a5d9ceef5ba31c556341f7ce1bc1b52d96b063f6c2c4765651",
+        "size_in_bytes": 3344
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_exec.py",
+        "path_type": "hardlink",
+        "sha256": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52",
+        "sha256_in_prefix": "9e0893327205dea12004e88d18c580286e7977e081b5eda7baf5b7bc93bc6c52",
+        "size_in_bytes": 979
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_execfile.py",
+        "path_type": "hardlink",
+        "sha256": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb",
+        "sha256_in_prefix": "6ff65db1192099457cb3d9f2618a893c6ac430028550284f3a34d5c08042b0eb",
+        "size_in_bytes": 2048
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_exitfunc.py",
+        "path_type": "hardlink",
+        "sha256": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c",
+        "sha256_in_prefix": "ef4f18f651d32410c43644c27590903d41e38e763b0e108e6c685a3412a7d29c",
+        "size_in_bytes": 2495
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_filter.py",
+        "path_type": "hardlink",
+        "sha256": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21",
+        "sha256_in_prefix": "2c7f0121193395750eab2b2abf5059d9a3b1a61f81763f52511265d7bca5cb21",
+        "size_in_bytes": 2765
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_funcattrs.py",
+        "path_type": "hardlink",
+        "sha256": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd",
+        "sha256_in_prefix": "111df53fac6a121d61abe33883a68e731820ddc4864b0a4c1000cf2ac5f019cd",
+        "size_in_bytes": 644
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_future.py",
+        "path_type": "hardlink",
+        "sha256": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663",
+        "sha256_in_prefix": "baba8cafb48dd9181a0e1f7b0f20b585ce2925e8f347e00b87407a256bb16663",
+        "size_in_bytes": 547
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_getcwdu.py",
+        "path_type": "hardlink",
+        "sha256": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220",
+        "sha256_in_prefix": "5bc5252f683a401e7d81c5911617c4af1a1bcdf99a51c4bf1cfccb00446ff220",
+        "size_in_bytes": 451
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_has_key.py",
+        "path_type": "hardlink",
+        "sha256": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63",
+        "sha256_in_prefix": "32943d3b921c1c3f0d3776d19e5120806990b817bc99a7e22799847abfda1f63",
+        "size_in_bytes": 3196
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_idioms.py",
+        "path_type": "hardlink",
+        "sha256": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7",
+        "sha256_in_prefix": "600e34faf36e14307e59d55088e3979881d497b8fc9d77659e77709f9e8bafd7",
+        "size_in_bytes": 4876
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_import.py",
+        "path_type": "hardlink",
+        "sha256": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e",
+        "sha256_in_prefix": "803baf96f9603c957eb974f252b0ad9829c889a293e0ce6829db1bce3da6dd4e",
+        "size_in_bytes": 3256
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_imports.py",
+        "path_type": "hardlink",
+        "sha256": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370",
+        "sha256_in_prefix": "cdf7ee6d85e2b148230984cfc4ea3f193be458958ea42ef290854a9672a64370",
+        "size_in_bytes": 5684
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_imports2.py",
+        "path_type": "hardlink",
+        "sha256": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef",
+        "sha256_in_prefix": "b6f3c628839ffe7fd72569dd6ca2210e18edae3e180002747ea011b76b7ec0ef",
+        "size_in_bytes": 289
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_input.py",
+        "path_type": "hardlink",
+        "sha256": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1",
+        "sha256_in_prefix": "10c5ef3b45a4ee7e88af8852181916a788aae2bea52b08f3473815c1c43598d1",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_intern.py",
+        "path_type": "hardlink",
+        "sha256": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66",
+        "sha256_in_prefix": "8d29a162536b99c91bd2f9259dda7f39fec751949d6354d2c1f2e5d070c87d66",
+        "size_in_bytes": 1144
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_isinstance.py",
+        "path_type": "hardlink",
+        "sha256": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914",
+        "sha256_in_prefix": "8408c92b99f50d8c4978b47a2b2155588e315f2ebbe58c160dcdcdcb89e19914",
+        "size_in_bytes": 1608
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_itertools.py",
+        "path_type": "hardlink",
+        "sha256": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1",
+        "sha256_in_prefix": "578a51b9935020b03a510de15ece55fcd02c9474f37a54c158fb97ba5fd15af1",
+        "size_in_bytes": 1548
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_itertools_imports.py",
+        "path_type": "hardlink",
+        "sha256": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7",
+        "sha256_in_prefix": "2e419cfbd7f2a326ae7fa10873aa377112ebec32545238fdf988acb088c3cdb7",
+        "size_in_bytes": 2086
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_long.py",
+        "path_type": "hardlink",
+        "sha256": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551",
+        "sha256_in_prefix": "306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551",
+        "size_in_bytes": 476
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_map.py",
+        "path_type": "hardlink",
+        "sha256": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696",
+        "sha256_in_prefix": "b82c0762c44adf2af7745c030afe291e2badfe360925046c8e58d85340717696",
+        "size_in_bytes": 3640
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_metaclass.py",
+        "path_type": "hardlink",
+        "sha256": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1",
+        "sha256_in_prefix": "45a30c866aa2ff69e089da147ed09986aad4516b5e5dd943f8dfcb7d3946a3e1",
+        "size_in_bytes": 8197
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_methodattrs.py",
+        "path_type": "hardlink",
+        "sha256": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8",
+        "sha256_in_prefix": "8d60082f98ce52ee4955099bfd447cbadfa0e9b24ccb8d135cecc833168d44e8",
+        "size_in_bytes": 606
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_ne.py",
+        "path_type": "hardlink",
+        "sha256": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd",
+        "sha256_in_prefix": "4f9cb1388ba86f29422d20979d3423fdf3541ba35a17ed44d6f4a517ff784ecd",
+        "size_in_bytes": 571
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_next.py",
+        "path_type": "hardlink",
+        "sha256": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd",
+        "sha256_in_prefix": "5c7d86d9f81b2498486d626c7feced1b92f23171cf9e42881abb78de1a93bccd",
+        "size_in_bytes": 3174
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_nonzero.py",
+        "path_type": "hardlink",
+        "sha256": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736",
+        "sha256_in_prefix": "c2cd7e3ba44508643a20eec4ea4c19f2f1adfd36f6b974d7c143e449571ae736",
+        "size_in_bytes": 591
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_numliterals.py",
+        "path_type": "hardlink",
+        "sha256": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f",
+        "sha256_in_prefix": "1c4dd0f7881999abde6cf4d232836fa3e55fc41a7d5aa2b9866092f65707db7f",
+        "size_in_bytes": 768
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_operator.py",
+        "path_type": "hardlink",
+        "sha256": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86",
+        "sha256_in_prefix": "023872fe9f03a25387cf2c17fc950cf0f990353df66e603c3a1cd3199dbccd86",
+        "size_in_bytes": 3426
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_paren.py",
+        "path_type": "hardlink",
+        "sha256": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d",
+        "sha256_in_prefix": "53734f1d7778ad28a4ec3ab4415923e2da8f230de4cd527589829f570e9f254d",
+        "size_in_bytes": 1226
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_print.py",
+        "path_type": "hardlink",
+        "sha256": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba",
+        "sha256_in_prefix": "cf2690f1b502249289f52cd544190db0b94d59df5eca139829cd2bf0742e9dba",
+        "size_in_bytes": 2844
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_raise.py",
+        "path_type": "hardlink",
+        "sha256": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5",
+        "sha256_in_prefix": "c38ffec5862597ee8f9dac50385af943ee312bfc394366be08b2fc12563ca1a5",
+        "size_in_bytes": 2926
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_raw_input.py",
+        "path_type": "hardlink",
+        "sha256": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b",
+        "sha256_in_prefix": "ce04cbaa76d414949afc230360dd9a29ff579bd868cc7f8805230d126ac9ce9b",
+        "size_in_bytes": 454
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_reduce.py",
+        "path_type": "hardlink",
+        "sha256": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919",
+        "sha256_in_prefix": "9a03910a6c183586e1db01863fcde6417d06745fb3e63032333d71c5e82e7919",
+        "size_in_bytes": 837
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_reload.py",
+        "path_type": "hardlink",
+        "sha256": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f",
+        "sha256_in_prefix": "17570148167e43b2155b6e1c814a3cca9e3ef53750c504932a9c7d62a8b68a3f",
+        "size_in_bytes": 1081
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_renames.py",
+        "path_type": "hardlink",
+        "sha256": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d",
+        "sha256_in_prefix": "8b71472317bf3adabf819e665c725d03e3064baa45f6ffbfd78cca83eaa46e8d",
+        "size_in_bytes": 2221
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_repr.py",
+        "path_type": "hardlink",
+        "sha256": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d",
+        "sha256_in_prefix": "d16930b7ef8577747cfef602aba854c64ce85d4ae1e54a18a456eaa202643e3d",
+        "size_in_bytes": 613
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_set_literal.py",
+        "path_type": "hardlink",
+        "sha256": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727",
+        "sha256_in_prefix": "33f2c0b6e16357e083c3a98877e7317abe1578a44c288e5979c9d96fb5aa6727",
+        "size_in_bytes": 1697
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_standarderror.py",
+        "path_type": "hardlink",
+        "sha256": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a",
+        "sha256_in_prefix": "ce7eb37bc7fb29aa138b1cec6656ae8b4886cbfa700e119a1bb8484284cb717a",
+        "size_in_bytes": 449
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_sys_exc.py",
+        "path_type": "hardlink",
+        "sha256": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a",
+        "sha256_in_prefix": "0143830586d09d702ca3eeaa8f86698e5fd18af69fd28147e71a1a77600d356a",
+        "size_in_bytes": 1034
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_throw.py",
+        "path_type": "hardlink",
+        "sha256": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901",
+        "sha256_in_prefix": "fec731ed523d5cdfa21893833b52b2844eabfd1549792c1c9f8ceac2d0e8e901",
+        "size_in_bytes": 1582
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_tuple_params.py",
+        "path_type": "hardlink",
+        "sha256": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72",
+        "sha256_in_prefix": "f3307d4750d0657d9c42b857d5f37bdb5824f9358939da7d16d13f61eb8abc72",
+        "size_in_bytes": 5565
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_types.py",
+        "path_type": "hardlink",
+        "sha256": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484",
+        "sha256_in_prefix": "a0a133cfc78e82e1f71ce628408e7d10a38552ba3e3228ebd113838c1ce44484",
+        "size_in_bytes": 1774
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_unicode.py",
+        "path_type": "hardlink",
+        "sha256": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097",
+        "sha256_in_prefix": "01b2a9b1084b6a0424f27eec488c761f75f053a409608ec36a9ee0ede0d38097",
+        "size_in_bytes": 1256
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_urllib.py",
+        "path_type": "hardlink",
+        "sha256": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856",
+        "sha256_in_prefix": "3d1c04d976ff4d2841025a785aaab0cc4ee06c9c9b4e09d1e2456949fa273856",
+        "size_in_bytes": 8367
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_ws_comma.py",
+        "path_type": "hardlink",
+        "sha256": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd",
+        "sha256_in_prefix": "5e7a16daec0b2619110516804bf90cac459a4d0315198fd4eff69c36c54378dd",
+        "size_in_bytes": 1090
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_xrange.py",
+        "path_type": "hardlink",
+        "sha256": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2",
+        "sha256_in_prefix": "60d8ce92db6f399606d2e40a3c631ba566127e8cd637ebbf35b822672139cab2",
+        "size_in_bytes": 2694
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_xreadlines.py",
+        "path_type": "hardlink",
+        "sha256": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba",
+        "sha256_in_prefix": "e8c2f19f7047bfc7539fd78839929004d8fe0efba1fbcbd9d712d285e43834ba",
+        "size_in_bytes": 689
+      },
+      {
+        "_path": "Lib/lib2to3/fixes/fix_zip.py",
+        "path_type": "hardlink",
+        "sha256": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb",
+        "sha256_in_prefix": "55ce115556c7513dd967364dc6a40c39210c874e8168cf090ddd6dc606df34cb",
+        "size_in_bytes": 1289
+      },
+      {
+        "_path": "Lib/lib2to3/main.py",
+        "path_type": "hardlink",
+        "sha256": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8",
+        "sha256_in_prefix": "8f5dfa77b8c8b375daba8bb88aaa195395674311e2513b29575a70821e3aa0b8",
+        "size_in_bytes": 11854
+      },
+      {
+        "_path": "Lib/lib2to3/patcomp.py",
+        "path_type": "hardlink",
+        "sha256": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5",
+        "sha256_in_prefix": "a033a3eb91a39f96747d4300aa3394965e529c71896cd6503dd27e6b685eede5",
+        "size_in_bytes": 7054
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500",
+        "sha256_in_prefix": "858eb0f50533bd3bd16fe32815f77fabfed92ede885070b6cb15827ec66ea500",
+        "size_in_bytes": 143
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b4f54789dd5c2d1a0675edebaec5b8d42cf47206242efefdb7c2aeefc7957974",
+        "sha256_in_prefix": "b4f54789dd5c2d1a0675edebaec5b8d42cf47206242efefdb7c2aeefc7957974",
+        "size_in_bytes": 150
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__pycache__/conv.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "40497959a290f8df346f59cba68d433328ebe03a32a15ac0db069b87b0946c0d",
+        "sha256_in_prefix": "40497959a290f8df346f59cba68d433328ebe03a32a15ac0db069b87b0946c0d",
+        "size_in_bytes": 6978
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__pycache__/driver.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "50612126c306b283ddee592bb4c447609226d89e7f52bcd6e1aa25f337f659b8",
+        "sha256_in_prefix": "50612126c306b283ddee592bb4c447609226d89e7f52bcd6e1aa25f337f659b8",
+        "size_in_bytes": 5112
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__pycache__/grammar.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "74b2f5afbb9a2919da2f88059a96a77bd925f899d4d145fc152412ab8021e521",
+        "sha256_in_prefix": "74b2f5afbb9a2919da2f88059a96a77bd925f899d4d145fc152412ab8021e521",
+        "size_in_bytes": 5690
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__pycache__/literals.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7d64574382566b7358b7b3aa5be51564410b7ddbf2a5f1ae71e79bc62fe14270",
+        "sha256_in_prefix": "7d64574382566b7358b7b3aa5be51564410b7ddbf2a5f1ae71e79bc62fe14270",
+        "size_in_bytes": 1514
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__pycache__/parse.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "208e56bfddd3efc1e6d28f440d1375216cda2aa8edeecb6825dcdbc918936fb5",
+        "sha256_in_prefix": "208e56bfddd3efc1e6d28f440d1375216cda2aa8edeecb6825dcdbc918936fb5",
+        "size_in_bytes": 6463
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__pycache__/pgen.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ca63e2bfe51b145a87a54c08c9e2989665c2698a10acc9cf7bdbfb574a1add7a",
+        "sha256_in_prefix": "ca63e2bfe51b145a87a54c08c9e2989665c2698a10acc9cf7bdbfb574a1add7a",
+        "size_in_bytes": 9705
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__pycache__/token.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5079f51a339a43dad8e1fbdde43a3734855984f7370d90f1b28d2efc72217e18",
+        "sha256_in_prefix": "5079f51a339a43dad8e1fbdde43a3734855984f7370d90f1b28d2efc72217e18",
+        "size_in_bytes": 1872
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/__pycache__/tokenize.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "259f7cc043e2166e015b7d2ec60bdca93c45c86a2e62ce9ec0490bd18f86427d",
+        "sha256_in_prefix": "259f7cc043e2166e015b7d2ec60bdca93c45c86a2e62ce9ec0490bd18f86427d",
+        "size_in_bytes": 15156
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/conv.py",
+        "path_type": "hardlink",
+        "sha256": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff",
+        "sha256_in_prefix": "e2946a686c12e02248fafb1a57e7514e0c22bdb2b4a66e644215c86fedc37bff",
+        "size_in_bytes": 9642
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/driver.py",
+        "path_type": "hardlink",
+        "sha256": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594",
+        "sha256_in_prefix": "57af5e220cd6c6b75e8dead2cea395ead2297dd98e398ad705ca2bce0e9e6594",
+        "size_in_bytes": 5969
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/grammar.py",
+        "path_type": "hardlink",
+        "sha256": "b04309478d2086cde92de4ba62c87bd986d05d7181c51e186a30d64468c95fa9",
+        "sha256_in_prefix": "b04309478d2086cde92de4ba62c87bd986d05d7181c51e186a30d64468c95fa9",
+        "size_in_bytes": 5533
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/literals.py",
+        "path_type": "hardlink",
+        "sha256": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a",
+        "sha256_in_prefix": "84bc9d5387a2e20fab844e530358571afa39fa3fc0e8024270b5f7d8ac5a595a",
+        "size_in_bytes": 1635
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/parse.py",
+        "path_type": "hardlink",
+        "sha256": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6",
+        "sha256_in_prefix": "e245e005e524ab445a570df31f70c6fd7b901ee3b0b68bd3bcf4b41b37fa7bb6",
+        "size_in_bytes": 8155
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/pgen.py",
+        "path_type": "hardlink",
+        "sha256": "2491291537fedb8765dca1c5e2ba34c0a0e3980e4ca3e3bb2b0d3ee293f37861",
+        "sha256_in_prefix": "2491291537fedb8765dca1c5e2ba34c0a0e3980e4ca3e3bb2b0d3ee293f37861",
+        "size_in_bytes": 13812
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/token.py",
+        "path_type": "hardlink",
+        "sha256": "47c7f968e1e3bf66d53fb4a6a9fc848cdae11d66d49bb70c7cf41961ea91f30c",
+        "sha256_in_prefix": "47c7f968e1e3bf66d53fb4a6a9fc848cdae11d66d49bb70c7cf41961ea91f30c",
+        "size_in_bytes": 1302
+      },
+      {
+        "_path": "Lib/lib2to3/pgen2/tokenize.py",
+        "path_type": "hardlink",
+        "sha256": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4",
+        "sha256_in_prefix": "aaa0b98f6a65e08e9f8e34358198e329d29554a0d4b5f5059924a252eeb0f5c4",
+        "size_in_bytes": 21119
+      },
+      {
+        "_path": "Lib/lib2to3/pygram.py",
+        "path_type": "hardlink",
+        "sha256": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48",
+        "sha256_in_prefix": "b49d77876a9d1822ff6be04daf464341a8e4c0c3414240abf519254de2a97a48",
+        "size_in_bytes": 1305
+      },
+      {
+        "_path": "Lib/lib2to3/pytree.py",
+        "path_type": "hardlink",
+        "sha256": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9",
+        "sha256_in_prefix": "e53689352fb4fc83d85a09369650389ee01db802ad872a8abfc0bf6603ec38b9",
+        "size_in_bytes": 27974
+      },
+      {
+        "_path": "Lib/lib2to3/refactor.py",
+        "path_type": "hardlink",
+        "sha256": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b",
+        "sha256_in_prefix": "6e9a4262fb65cd4d277f009df73ffa5748f5fe3b963d3c5395c160d5f88b089b",
+        "size_in_bytes": 27507
+      },
+      {
+        "_path": "Lib/linecache.py",
+        "path_type": "hardlink",
+        "sha256": "766a5ba5a7692a819f366df0e2e6fb3ba5fc9677aa77188a91c001bddf6e908b",
+        "sha256_in_prefix": "766a5ba5a7692a819f366df0e2e6fb3ba5fc9677aa77188a91c001bddf6e908b",
+        "size_in_bytes": 5461
+      },
+      {
+        "_path": "Lib/locale.py",
+        "path_type": "hardlink",
+        "sha256": "4a5df24c0fe4ea0ce1ea3331365bd80a3060069109e615b66a4c9968fecd438f",
+        "sha256_in_prefix": "4a5df24c0fe4ea0ce1ea3331365bd80a3060069109e615b66a4c9968fecd438f",
+        "size_in_bytes": 78271
+      },
+      {
+        "_path": "Lib/logging/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "56401d56036a87062af2ff2cfa60ac31855a969931e79447b64d24174339654a",
+        "sha256_in_prefix": "56401d56036a87062af2ff2cfa60ac31855a969931e79447b64d24174339654a",
+        "size_in_bytes": 78600
+      },
+      {
+        "_path": "Lib/logging/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b049654075fb6fc469f8872849b7236ce8c340aca2f91805f40dd974ce2a5970",
+        "sha256_in_prefix": "b049654075fb6fc469f8872849b7236ce8c340aca2f91805f40dd974ce2a5970",
+        "size_in_bytes": 66311
+      },
+      {
+        "_path": "Lib/logging/__pycache__/config.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b1374ec196d981d9868f0a3e5a0ec94c43dac5c929958c526caf2894f9f8d2e3",
+        "sha256_in_prefix": "b1374ec196d981d9868f0a3e5a0ec94c43dac5c929958c526caf2894f9f8d2e3",
+        "size_in_bytes": 23240
+      },
+      {
+        "_path": "Lib/logging/__pycache__/handlers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9f43cd82bbff4827c2d25221382efa5c3e223592b2b128925cb13c88f6dfea20",
+        "sha256_in_prefix": "9f43cd82bbff4827c2d25221382efa5c3e223592b2b128925cb13c88f6dfea20",
+        "size_in_bytes": 44177
+      },
+      {
+        "_path": "Lib/logging/config.py",
+        "path_type": "hardlink",
+        "sha256": "24103e6abc55fc115089d3643b63affc50c1805cd2ae7afece2414e1a45291f3",
+        "sha256_in_prefix": "24103e6abc55fc115089d3643b63affc50c1805cd2ae7afece2414e1a45291f3",
+        "size_in_bytes": 36379
+      },
+      {
+        "_path": "Lib/logging/handlers.py",
+        "path_type": "hardlink",
+        "sha256": "b270dc1332a3541f6a2b4d7f510327e1b781e2652c728224a2cc6063a0857299",
+        "sha256_in_prefix": "b270dc1332a3541f6a2b4d7f510327e1b781e2652c728224a2cc6063a0857299",
+        "size_in_bytes": 60423
+      },
+      {
+        "_path": "Lib/lzma.py",
+        "path_type": "hardlink",
+        "sha256": "497227c971f4b6407c86fb31254a10edfe4c97c017e63a5eca026a8ba112a165",
+        "sha256_in_prefix": "497227c971f4b6407c86fb31254a10edfe4c97c017e63a5eca026a8ba112a165",
+        "size_in_bytes": 13231
+      },
+      {
+        "_path": "Lib/mailbox.py",
+        "path_type": "hardlink",
+        "sha256": "e695a76d936f009d926e50eae09e34e1256ceee86ffb5b5825748e98f9080036",
+        "sha256_in_prefix": "e695a76d936f009d926e50eae09e34e1256ceee86ffb5b5825748e98f9080036",
+        "size_in_bytes": 78794
+      },
+      {
+        "_path": "Lib/mailcap.py",
+        "path_type": "hardlink",
+        "sha256": "b0ce7d29e8233ec412ac6aa16a9e62b3353d4acd44c6b870f6b6ffe1dbebba6f",
+        "sha256_in_prefix": "b0ce7d29e8233ec412ac6aa16a9e62b3353d4acd44c6b870f6b6ffe1dbebba6f",
+        "size_in_bytes": 9116
+      },
+      {
+        "_path": "Lib/mimetypes.py",
+        "path_type": "hardlink",
+        "sha256": "3008c1c799243922539bc6c9f2206eff428eb6d7cb117629638fab4fa048d3e4",
+        "sha256_in_prefix": "3008c1c799243922539bc6c9f2206eff428eb6d7cb117629638fab4fa048d3e4",
+        "size_in_bytes": 21564
+      },
+      {
+        "_path": "Lib/modulefinder.py",
+        "path_type": "hardlink",
+        "sha256": "eccfc7972b42dc3064832d3b98d2db8e1486d570d75c80a874cdb55b84d6e05e",
+        "sha256_in_prefix": "eccfc7972b42dc3064832d3b98d2db8e1486d570d75c80a874cdb55b84d6e05e",
+        "size_in_bytes": 24401
+      },
+      {
+        "_path": "Lib/msilib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "0a560023ff175df12eb07f87bb1d663907bee61b2e6cd4918e0916d7c5770f26",
+        "sha256_in_prefix": "0a560023ff175df12eb07f87bb1d663907bee61b2e6cd4918e0916d7c5770f26",
+        "size_in_bytes": 17591
+      },
+      {
+        "_path": "Lib/msilib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0d060f9aed826a2c6d193ffce6da21f14245ef2bfc9ab6e1fb4115cceaf09673",
+        "sha256_in_prefix": "0d060f9aed826a2c6d193ffce6da21f14245ef2bfc9ab6e1fb4115cceaf09673",
+        "size_in_bytes": 15865
+      },
+      {
+        "_path": "Lib/msilib/__pycache__/schema.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e6f3f635eabec817aaf525921a254496673fd896e2483b8c19d9cabb795605b5",
+        "sha256_in_prefix": "e6f3f635eabec817aaf525921a254496673fd896e2483b8c19d9cabb795605b5",
+        "size_in_bytes": 49613
+      },
+      {
+        "_path": "Lib/msilib/__pycache__/sequence.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8b7dc7f42f4ed57f5742bd14cd992e852332a0eb5886c8eefac0370c3779fa3b",
+        "sha256_in_prefix": "8b7dc7f42f4ed57f5742bd14cd992e852332a0eb5886c8eefac0370c3779fa3b",
+        "size_in_bytes": 2366
+      },
+      {
+        "_path": "Lib/msilib/__pycache__/text.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a66b4bca2ef06e107a3dad385c7fe96a855fa9f8e41a12dd722f5c74e5eed8f8",
+        "sha256_in_prefix": "a66b4bca2ef06e107a3dad385c7fe96a855fa9f8e41a12dd722f5c74e5eed8f8",
+        "size_in_bytes": 7977
+      },
+      {
+        "_path": "Lib/msilib/schema.py",
+        "path_type": "hardlink",
+        "sha256": "a7d6c1a4699a75bb88a8a012adbb64142dc47adcc31212c3c0e7ae092b4161ae",
+        "sha256_in_prefix": "a7d6c1a4699a75bb88a8a012adbb64142dc47adcc31212c3c0e7ae092b4161ae",
+        "size_in_bytes": 81579
+      },
+      {
+        "_path": "Lib/msilib/sequence.py",
+        "path_type": "hardlink",
+        "sha256": "a68438bacd41b60c5359b5c5ef32163249f69233292fa94acd53535cb08cd65d",
+        "sha256_in_prefix": "a68438bacd41b60c5359b5c5ef32163249f69233292fa94acd53535cb08cd65d",
+        "size_in_bytes": 3929
+      },
+      {
+        "_path": "Lib/msilib/text.py",
+        "path_type": "hardlink",
+        "sha256": "fe5bc6023fc58e01e1c80fbe21304ccd6aadd8c384fe6afebed279c3d2925de4",
+        "sha256_in_prefix": "fe5bc6023fc58e01e1c80fbe21304ccd6aadd8c384fe6afebed279c3d2925de4",
+        "size_in_bytes": 9018
+      },
+      {
+        "_path": "Lib/multiprocessing/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b",
+        "sha256_in_prefix": "a5a42976033c7d63ee2740acceef949a3582dcb0e0442845f9717e1be771c68b",
+        "size_in_bytes": 916
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1ba5e70e3921355453b2be71040faac7c493ec1226b8304f789eca4cbdeab6de",
+        "sha256_in_prefix": "1ba5e70e3921355453b2be71040faac7c493ec1226b8304f789eca4cbdeab6de",
+        "size_in_bytes": 637
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/connection.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "99d2b32013a14d9934257f505ae31c893907e30bf4673c0d46a51fbd442ec14a",
+        "sha256_in_prefix": "99d2b32013a14d9934257f505ae31c893907e30bf4673c0d46a51fbd442ec14a",
+        "size_in_bytes": 25566
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/context.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e9ada55286c00f1e40cec9d8687e8406bf304faba133a0bdcc35058de0288716",
+        "sha256_in_prefix": "e9ada55286c00f1e40cec9d8687e8406bf304faba133a0bdcc35058de0288716",
+        "size_in_bytes": 13003
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/forkserver.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8bc078457d61894932350d975e6b4b46c2325759da71a4585706094669cc1358",
+        "sha256_in_prefix": "8bc078457d61894932350d975e6b4b46c2325759da71a4585706094669cc1358",
+        "size_in_bytes": 8400
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/heap.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "69e4a0259460db19ac3205d9271adb1c6cd19c6c3e5dac79b968eab3c33aa498",
+        "sha256_in_prefix": "69e4a0259460db19ac3205d9271adb1c6cd19c6c3e5dac79b968eab3c33aa498",
+        "size_in_bytes": 7618
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/managers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e07c3dc4e4fe7388ddc2e441247ed7067597e053b922b4d920933ecfebf47078",
+        "sha256_in_prefix": "e07c3dc4e4fe7388ddc2e441247ed7067597e053b922b4d920933ecfebf47078",
+        "size_in_bytes": 40891
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/pool.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5b8325ebb313f6c681b0a4d48d725dfa2f001c3ebb28db7fd626cf907d99e052",
+        "sha256_in_prefix": "5b8325ebb313f6c681b0a4d48d725dfa2f001c3ebb28db7fd626cf907d99e052",
+        "size_in_bytes": 25121
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/popen_fork.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a3a87d27158dc438797f4c3e2542f3a7acc44b31fa3b9d3b7813b5461ef7014d",
+        "sha256_in_prefix": "a3a87d27158dc438797f4c3e2542f3a7acc44b31fa3b9d3b7813b5461ef7014d",
+        "size_in_bytes": 2495
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/popen_forkserver.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5b3ee9d93faa2a49e64abe8bd80cfe37a8e6395cb64af3bbf522b357b3aec280",
+        "sha256_in_prefix": "5b3ee9d93faa2a49e64abe8bd80cfe37a8e6395cb64af3bbf522b357b3aec280",
+        "size_in_bytes": 2428
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/popen_spawn_posix.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "04ec3bf09f71e2094bb989b57ad4a38928bd4b1d3e37a39bb6c039c964f7a0d3",
+        "sha256_in_prefix": "04ec3bf09f71e2094bb989b57ad4a38928bd4b1d3e37a39bb6c039c964f7a0d3",
+        "size_in_bytes": 2331
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/popen_spawn_win32.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c4603f5e7bb1d38b1beffd778f55eccc0c89db1929dd44a3cac0bd9ac2497685",
+        "sha256_in_prefix": "c4603f5e7bb1d38b1beffd778f55eccc0c89db1929dd44a3cac0bd9ac2497685",
+        "size_in_bytes": 3440
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/process.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a59433881b90769744169d40dc3a99005b6267c5190de78e1184c4f6d6210b8d",
+        "sha256_in_prefix": "a59433881b90769744169d40dc3a99005b6267c5190de78e1184c4f6d6210b8d",
+        "size_in_bytes": 10992
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/queues.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7302c852724d2f07436f417c70f5f6354b95f9f759a0684f674f235fd90461bd",
+        "sha256_in_prefix": "7302c852724d2f07436f417c70f5f6354b95f9f759a0684f674f235fd90461bd",
+        "size_in_bytes": 10159
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/reduction.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a2ed39a226d00037260123e98af0ed8747db2afc91c9d12153313f9ce954def8",
+        "sha256_in_prefix": "a2ed39a226d00037260123e98af0ed8747db2afc91c9d12153313f9ce954def8",
+        "size_in_bytes": 8268
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/resource_sharer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cf825e4a6cff1fbd64795ba7051d91df61294d0a2c36b27dd795f025a58c9235",
+        "sha256_in_prefix": "cf825e4a6cff1fbd64795ba7051d91df61294d0a2c36b27dd795f025a58c9235",
+        "size_in_bytes": 5267
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/resource_tracker.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f9bb983dca3ad1c1131e348c0322bba14063a1b26f726f0fea418b93a1a81319",
+        "sha256_in_prefix": "f9bb983dca3ad1c1131e348c0322bba14063a1b26f726f0fea418b93a1a81319",
+        "size_in_bytes": 5440
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/shared_memory.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "184815700908d3674e16395d943460608fde2fca06537d3d179515b3d61dcf51",
+        "sha256_in_prefix": "184815700908d3674e16395d943460608fde2fca06537d3d179515b3d61dcf51",
+        "size_in_bytes": 14425
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/sharedctypes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8aaf5d8aef784cfb73868cb2d34d5945921e52f6752ebf714adc5bf3d55dbc98",
+        "sha256_in_prefix": "8aaf5d8aef784cfb73868cb2d34d5945921e52f6752ebf714adc5bf3d55dbc98",
+        "size_in_bytes": 7080
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/spawn.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e4019c56bf248b8f1f2d93838cbe76768b8bc049cd617030e70589d8031abcfc",
+        "sha256_in_prefix": "e4019c56bf248b8f1f2d93838cbe76768b8bc049cd617030e70589d8031abcfc",
+        "size_in_bytes": 6704
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/synchronize.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3360cd7ba6c0d66615128965ae665a4a9f06d4ce63f5f93eed666e94c7e898c8",
+        "sha256_in_prefix": "3360cd7ba6c0d66615128965ae665a4a9f06d4ce63f5f93eed666e94c7e898c8",
+        "size_in_bytes": 11371
+      },
+      {
+        "_path": "Lib/multiprocessing/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "48b8347cf98401f5675bc167664719fa96e53e972a51407a9c7429af9f20093f",
+        "sha256_in_prefix": "48b8347cf98401f5675bc167664719fa96e53e972a51407a9c7429af9f20093f",
+        "size_in_bytes": 11489
+      },
+      {
+        "_path": "Lib/multiprocessing/connection.py",
+        "path_type": "hardlink",
+        "sha256": "a6c0161f3bf0c2c38d0a7797148a11aa0e5334d9f22cb9f50f4204c775e9072d",
+        "sha256_in_prefix": "a6c0161f3bf0c2c38d0a7797148a11aa0e5334d9f22cb9f50f4204c775e9072d",
+        "size_in_bytes": 31685
+      },
+      {
+        "_path": "Lib/multiprocessing/context.py",
+        "path_type": "hardlink",
+        "sha256": "f3f7839e663a42eb0e0a6669057b0763032e428f546f8185b748fdff8f98a333",
+        "sha256_in_prefix": "f3f7839e663a42eb0e0a6669057b0763032e428f546f8185b748fdff8f98a333",
+        "size_in_bytes": 11257
+      },
+      {
+        "_path": "Lib/multiprocessing/dummy/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90",
+        "sha256_in_prefix": "9127a40ea0ff342cb414383b5e7c594a05be2dd835fe246bd3bb0dc036a32a90",
+        "size_in_bytes": 3061
+      },
+      {
+        "_path": "Lib/multiprocessing/dummy/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d10746248d95ac8364f628fd7487d06cd1e55a2757cebe192d3f7fa2c28a4f2b",
+        "sha256_in_prefix": "d10746248d95ac8364f628fd7487d06cd1e55a2757cebe192d3f7fa2c28a4f2b",
+        "size_in_bytes": 3848
+      },
+      {
+        "_path": "Lib/multiprocessing/dummy/__pycache__/connection.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d67e8092bc31eae190bd21936c7c113798dd21c1b494894d00bfd3eb2d50bf8d",
+        "sha256_in_prefix": "d67e8092bc31eae190bd21936c7c113798dd21c1b494894d00bfd3eb2d50bf8d",
+        "size_in_bytes": 2568
+      },
+      {
+        "_path": "Lib/multiprocessing/dummy/connection.py",
+        "path_type": "hardlink",
+        "sha256": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab",
+        "sha256_in_prefix": "d63dd1979fde9c133efe430ee870e6ba6de43c0a0513866ce3ce475791fe57ab",
+        "size_in_bytes": 1598
+      },
+      {
+        "_path": "Lib/multiprocessing/forkserver.py",
+        "path_type": "hardlink",
+        "sha256": "578e1a3733c81c09c70a1f427b467adb20c7197069d773e85ecd6e9236150a72",
+        "sha256_in_prefix": "578e1a3733c81c09c70a1f427b467adb20c7197069d773e85ecd6e9236150a72",
+        "size_in_bytes": 12142
+      },
+      {
+        "_path": "Lib/multiprocessing/heap.py",
+        "path_type": "hardlink",
+        "sha256": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614",
+        "sha256_in_prefix": "f6bb79bb99b9ae484935f0d68822e9603a1622dd0b6c4966c79db232a93ba614",
+        "size_in_bytes": 11626
+      },
+      {
+        "_path": "Lib/multiprocessing/managers.py",
+        "path_type": "hardlink",
+        "sha256": "f9d7642d2752e75e417808fb207b246c88adcabd7cf070cceebc7f627196ac3c",
+        "sha256_in_prefix": "f9d7642d2752e75e417808fb207b246c88adcabd7cf070cceebc7f627196ac3c",
+        "size_in_bytes": 47303
+      },
+      {
+        "_path": "Lib/multiprocessing/pool.py",
+        "path_type": "hardlink",
+        "sha256": "b3cf915bfb015a3654a276e03b2ad624312bfb25be9fb80fb2925359171e29b8",
+        "sha256_in_prefix": "b3cf915bfb015a3654a276e03b2ad624312bfb25be9fb80fb2925359171e29b8",
+        "size_in_bytes": 32555
+      },
+      {
+        "_path": "Lib/multiprocessing/popen_fork.py",
+        "path_type": "hardlink",
+        "sha256": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95",
+        "sha256_in_prefix": "0a09db57e7fab7061c01a61778feea6e2b6bb02ccbc150332f2960b05258ef95",
+        "size_in_bytes": 2377
+      },
+      {
+        "_path": "Lib/multiprocessing/popen_forkserver.py",
+        "path_type": "hardlink",
+        "sha256": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab",
+        "sha256_in_prefix": "0588ad0e5a36718b4377dc2a2a97864a10986c25a33dc3bfed12595711b0cdab",
+        "size_in_bytes": 2230
+      },
+      {
+        "_path": "Lib/multiprocessing/popen_spawn_posix.py",
+        "path_type": "hardlink",
+        "sha256": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8",
+        "sha256_in_prefix": "97b5d25aa479516894489877e6a7921252ee35f51e118c2f1f91f32919e7caa8",
+        "size_in_bytes": 2029
+      },
+      {
+        "_path": "Lib/multiprocessing/popen_spawn_win32.py",
+        "path_type": "hardlink",
+        "sha256": "03dbaf94f9a13bc241ccd70453f1a68b1d90fea6095b53576605cfc2d379028d",
+        "sha256_in_prefix": "03dbaf94f9a13bc241ccd70453f1a68b1d90fea6095b53576605cfc2d379028d",
+        "size_in_bytes": 4011
+      },
+      {
+        "_path": "Lib/multiprocessing/process.py",
+        "path_type": "hardlink",
+        "sha256": "dce0e05617af80e97645758cbf757f1125f9fc21c930e5243907edb7ad7eaab1",
+        "sha256_in_prefix": "dce0e05617af80e97645758cbf757f1125f9fc21c930e5243907edb7ad7eaab1",
+        "size_in_bytes": 12000
+      },
+      {
+        "_path": "Lib/multiprocessing/queues.py",
+        "path_type": "hardlink",
+        "sha256": "c6a5e3d6918de807074142eb4257746093ca78ffd897d828d559b7ea711c71a8",
+        "sha256_in_prefix": "c6a5e3d6918de807074142eb4257746093ca78ffd897d828d559b7ea711c71a8",
+        "size_in_bytes": 12023
+      },
+      {
+        "_path": "Lib/multiprocessing/reduction.py",
+        "path_type": "hardlink",
+        "sha256": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe",
+        "sha256_in_prefix": "4999f8b9ae7b3e8a7f5de302612b4131498dc2e238a2c47f894905c1c63294fe",
+        "size_in_bytes": 9512
+      },
+      {
+        "_path": "Lib/multiprocessing/resource_sharer.py",
+        "path_type": "hardlink",
+        "sha256": "9c40292e1310a9df0aba77da34a9779fcbdd7a20863f12ab48bd496b49cd0049",
+        "sha256_in_prefix": "9c40292e1310a9df0aba77da34a9779fcbdd7a20863f12ab48bd496b49cd0049",
+        "size_in_bytes": 5132
+      },
+      {
+        "_path": "Lib/multiprocessing/resource_tracker.py",
+        "path_type": "hardlink",
+        "sha256": "d1b2cda150fca8ca4699a812212e5babcaf821a2e32eba845ae52e14ec95d7a3",
+        "sha256_in_prefix": "d1b2cda150fca8ca4699a812212e5babcaf821a2e32eba845ae52e14ec95d7a3",
+        "size_in_bytes": 8613
+      },
+      {
+        "_path": "Lib/multiprocessing/shared_memory.py",
+        "path_type": "hardlink",
+        "sha256": "604ccfe5a8cb97caaf471473efa76def6be80b903f10730bb30cf78a2dbe36f8",
+        "sha256_in_prefix": "604ccfe5a8cb97caaf471473efa76def6be80b903f10730bb30cf78a2dbe36f8",
+        "size_in_bytes": 18396
+      },
+      {
+        "_path": "Lib/multiprocessing/sharedctypes.py",
+        "path_type": "hardlink",
+        "sha256": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d",
+        "sha256_in_prefix": "77ef522912474652490b7df523112858e51721e63dcf109b8567a35ce9b31b0d",
+        "size_in_bytes": 6306
+      },
+      {
+        "_path": "Lib/multiprocessing/spawn.py",
+        "path_type": "hardlink",
+        "sha256": "16ce6d81f8b5ef7228e5500bff04b37bdceb3d7dfc8d6de3ad523598798c43f4",
+        "sha256_in_prefix": "16ce6d81f8b5ef7228e5500bff04b37bdceb3d7dfc8d6de3ad523598798c43f4",
+        "size_in_bytes": 9296
+      },
+      {
+        "_path": "Lib/multiprocessing/synchronize.py",
+        "path_type": "hardlink",
+        "sha256": "c357514f2359baf9570adcce2a6818a2456477019eaa138f26f8fcc2b6f467b0",
+        "sha256_in_prefix": "c357514f2359baf9570adcce2a6818a2456477019eaa138f26f8fcc2b6f467b0",
+        "size_in_bytes": 11610
+      },
+      {
+        "_path": "Lib/multiprocessing/util.py",
+        "path_type": "hardlink",
+        "sha256": "b106f66e336835726e289ef2010a39beaf9f83af7d8fe218fc4c9ea4c9551f54",
+        "sha256_in_prefix": "b106f66e336835726e289ef2010a39beaf9f83af7d8fe218fc4c9ea4c9551f54",
+        "size_in_bytes": 14006
+      },
+      {
+        "_path": "Lib/netrc.py",
+        "path_type": "hardlink",
+        "sha256": "e4104d403e949209f11173b91ecd304117952708d8ab79097fdce808473b71d4",
+        "sha256_in_prefix": "e4104d403e949209f11173b91ecd304117952708d8ab79097fdce808473b71d4",
+        "size_in_bytes": 5566
+      },
+      {
+        "_path": "Lib/nntplib.py",
+        "path_type": "hardlink",
+        "sha256": "4ff3d30528c355d965d93ccc123d31284905c0922befa08ad36387d2a8bbe84e",
+        "sha256_in_prefix": "4ff3d30528c355d965d93ccc123d31284905c0922befa08ad36387d2a8bbe84e",
+        "size_in_bytes": 41023
+      },
+      {
+        "_path": "Lib/ntpath.py",
+        "path_type": "hardlink",
+        "sha256": "d4dad66e55873f0649884f723271da7ab3efb6b7ffc55c02f6d231d377552950",
+        "sha256_in_prefix": "d4dad66e55873f0649884f723271da7ab3efb6b7ffc55c02f6d231d377552950",
+        "size_in_bytes": 27734
+      },
+      {
+        "_path": "Lib/nturl2path.py",
+        "path_type": "hardlink",
+        "sha256": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332",
+        "sha256_in_prefix": "980982ba66cc403d17874369d2770e09845b3d49f1d4514e1c52e01518114332",
+        "size_in_bytes": 2887
+      },
+      {
+        "_path": "Lib/numbers.py",
+        "path_type": "hardlink",
+        "sha256": "2873ef7bec8c8c213904581e84d228479a57c6abd8920dd39f766cd3a747550d",
+        "sha256_in_prefix": "2873ef7bec8c8c213904581e84d228479a57c6abd8920dd39f766cd3a747550d",
+        "size_in_bytes": 10338
+      },
+      {
+        "_path": "Lib/opcode.py",
+        "path_type": "hardlink",
+        "sha256": "51704446c56af48ba80718ec157f073f8032605e65c6a1988433621405945b76",
+        "sha256_in_prefix": "51704446c56af48ba80718ec157f073f8032605e65c6a1988433621405945b76",
+        "size_in_bytes": 5660
+      },
+      {
+        "_path": "Lib/operator.py",
+        "path_type": "hardlink",
+        "sha256": "fd931e2bf493ddd239208b0c0a2249324602b48aabc984c85b7d8dcc4d99a17d",
+        "sha256_in_prefix": "fd931e2bf493ddd239208b0c0a2249324602b48aabc984c85b7d8dcc4d99a17d",
+        "size_in_bytes": 10751
+      },
+      {
+        "_path": "Lib/optparse.py",
+        "path_type": "hardlink",
+        "sha256": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5",
+        "sha256_in_prefix": "07d224301cba312fa0697bff9cd5a4bb4f778a90629632091b3f4ae874d89af5",
+        "size_in_bytes": 60369
+      },
+      {
+        "_path": "Lib/os.py",
+        "path_type": "hardlink",
+        "sha256": "308a2b8820449cfdbaa625b7269e2631054bcc1d0bd8fef134e0d45acce67fe7",
+        "sha256_in_prefix": "308a2b8820449cfdbaa625b7269e2631054bcc1d0bd8fef134e0d45acce67fe7",
+        "size_in_bytes": 39065
+      },
+      {
+        "_path": "Lib/pathlib.py",
+        "path_type": "hardlink",
+        "sha256": "d6295627c41c7af8f465d113cf22646a72490ec49ff3f413b571159e75029b46",
+        "sha256_in_prefix": "d6295627c41c7af8f465d113cf22646a72490ec49ff3f413b571159e75029b46",
+        "size_in_bytes": 54073
+      },
+      {
+        "_path": "Lib/pdb.py",
+        "path_type": "hardlink",
+        "sha256": "8cdc3d32271ba86af27ab30bc1c1c392dbb4d7d5dc76795cdd907a9484cba21b",
+        "sha256_in_prefix": "8cdc3d32271ba86af27ab30bc1c1c392dbb4d7d5dc76795cdd907a9484cba21b",
+        "size_in_bytes": 63239
+      },
+      {
+        "_path": "Lib/pickle.py",
+        "path_type": "hardlink",
+        "sha256": "e7a24f839324b8efcaba7397f5576cdfd692f7562ccf57b4e464026489c700f0",
+        "sha256_in_prefix": "e7a24f839324b8efcaba7397f5576cdfd692f7562ccf57b4e464026489c700f0",
+        "size_in_bytes": 64920
+      },
+      {
+        "_path": "Lib/pickletools.py",
+        "path_type": "hardlink",
+        "sha256": "bcc8d00ebadd684aba19169e853e6f23bc36d609ae0c8119912f1e39e9f0c1e9",
+        "sha256_in_prefix": "bcc8d00ebadd684aba19169e853e6f23bc36d609ae0c8119912f1e39e9f0c1e9",
+        "size_in_bytes": 93486
+      },
+      {
+        "_path": "Lib/pipes.py",
+        "path_type": "hardlink",
+        "sha256": "b7979ff076f582ab9a6e92bf1aa283abcb2558ec87164f6f2615fe8772de9eda",
+        "sha256_in_prefix": "b7979ff076f582ab9a6e92bf1aa283abcb2558ec87164f6f2615fe8772de9eda",
+        "size_in_bytes": 8916
+      },
+      {
+        "_path": "Lib/pkgutil.py",
+        "path_type": "hardlink",
+        "sha256": "ea769cacc6393468d3c74c6671252e109598406937c50145d4bfb280462ff9fe",
+        "sha256_in_prefix": "ea769cacc6393468d3c74c6671252e109598406937c50145d4bfb280462ff9fe",
+        "size_in_bytes": 24276
+      },
+      {
+        "_path": "Lib/platform.py",
+        "path_type": "hardlink",
+        "sha256": "48fdda0d1f250791f0cc4ef0b5022b483ed588ef4827021d8ab2db498a4a9ee7",
+        "sha256_in_prefix": "48fdda0d1f250791f0cc4ef0b5022b483ed588ef4827021d8ab2db498a4a9ee7",
+        "size_in_bytes": 40767
+      },
+      {
+        "_path": "Lib/plistlib.py",
+        "path_type": "hardlink",
+        "sha256": "e20d714105cb791f4f193a6cd349369d3d9e3e399a4cb7eb9ed98e012ba90330",
+        "sha256_in_prefix": "e20d714105cb791f4f193a6cd349369d3d9e3e399a4cb7eb9ed98e012ba90330",
+        "size_in_bytes": 28248
+      },
+      {
+        "_path": "Lib/poplib.py",
+        "path_type": "hardlink",
+        "sha256": "7b341e6adb4e4341b211a221a7224849ea415fc1e39c014b05ae7d9a566819f4",
+        "sha256_in_prefix": "7b341e6adb4e4341b211a221a7224849ea415fc1e39c014b05ae7d9a566819f4",
+        "size_in_bytes": 15198
+      },
+      {
+        "_path": "Lib/posixpath.py",
+        "path_type": "hardlink",
+        "sha256": "fb37feaaf52ef7f9fec21b3da2518af9d464b735916700855d2331c429bd7762",
+        "sha256_in_prefix": "fb37feaaf52ef7f9fec21b3da2518af9d464b735916700855d2331c429bd7762",
+        "size_in_bytes": 15721
+      },
+      {
+        "_path": "Lib/pprint.py",
+        "path_type": "hardlink",
+        "sha256": "aa61351ae437e77961421b023741aa2b4b2ff0dac5fe7fe81e0cc6ecad802ad3",
+        "sha256_in_prefix": "aa61351ae437e77961421b023741aa2b4b2ff0dac5fe7fe81e0cc6ecad802ad3",
+        "size_in_bytes": 22527
+      },
+      {
+        "_path": "Lib/profile.py",
+        "path_type": "hardlink",
+        "sha256": "4d87bdc8b85bf0a9bdee3e9d975a8a1a0c7360cb264fb68c4c48a102e718e3a3",
+        "sha256_in_prefix": "4d87bdc8b85bf0a9bdee3e9d975a8a1a0c7360cb264fb68c4c48a102e718e3a3",
+        "size_in_bytes": 22883
+      },
+      {
+        "_path": "Lib/pstats.py",
+        "path_type": "hardlink",
+        "sha256": "cd1d23e6e49873170fb5c779cba798aebdb6e39545e070794c72658df29ee068",
+        "sha256_in_prefix": "cd1d23e6e49873170fb5c779cba798aebdb6e39545e070794c72658df29ee068",
+        "size_in_bytes": 29326
+      },
+      {
+        "_path": "Lib/pty.py",
+        "path_type": "hardlink",
+        "sha256": "6125252a7bc6a870d54c935a152440bde7502671d1fd2d863e96b799ec1ac942",
+        "sha256_in_prefix": "6125252a7bc6a870d54c935a152440bde7502671d1fd2d863e96b799ec1ac942",
+        "size_in_bytes": 4807
+      },
+      {
+        "_path": "Lib/py_compile.py",
+        "path_type": "hardlink",
+        "sha256": "987f1474401ce82ee6e8e4f2009ac1c0f8320100bc6575253f1568dea347c6b4",
+        "sha256_in_prefix": "987f1474401ce82ee6e8e4f2009ac1c0f8320100bc6575253f1568dea347c6b4",
+        "size_in_bytes": 8148
+      },
+      {
+        "_path": "Lib/pyclbr.py",
+        "path_type": "hardlink",
+        "sha256": "df9fd39b4bfd8be04754ab74a34268643697aeecd076b02427557f732dd1016e",
+        "sha256_in_prefix": "df9fd39b4bfd8be04754ab74a34268643697aeecd076b02427557f732dd1016e",
+        "size_in_bytes": 15255
+      },
+      {
+        "_path": "Lib/pydoc.py",
+        "path_type": "hardlink",
+        "sha256": "2d51dbde4e3e07e3224556f66a1196ee95a053db622d8f91b9cfa40239f70230",
+        "sha256_in_prefix": "2d51dbde4e3e07e3224556f66a1196ee95a053db622d8f91b9cfa40239f70230",
+        "size_in_bytes": 109600
+      },
+      {
+        "_path": "Lib/pydoc_data/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/pydoc_data/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c576af8a2a89ded427442f9fbd63aa894b13d6e6ae897fa0317c90a9a5a0eda9",
+        "sha256_in_prefix": "c576af8a2a89ded427442f9fbd63aa894b13d6e6ae897fa0317c90a9a5a0eda9",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "Lib/pydoc_data/__pycache__/topics.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dc269ee1b51e6be75841f972ab85fa62af222a020b772f17c97a17974019482a",
+        "sha256_in_prefix": "dc269ee1b51e6be75841f972ab85fa62af222a020b772f17c97a17974019482a",
+        "size_in_bytes": 436250
+      },
+      {
+        "_path": "Lib/pydoc_data/_pydoc.css",
+        "path_type": "hardlink",
+        "sha256": "7b8cc50cbc204745d38fa3d57b3bd6bb4c3f6ea0d346bef61b3cc423eb15b9d1",
+        "sha256_in_prefix": "7b8cc50cbc204745d38fa3d57b3bd6bb4c3f6ea0d346bef61b3cc423eb15b9d1",
+        "size_in_bytes": 96
+      },
+      {
+        "_path": "Lib/pydoc_data/topics.py",
+        "path_type": "hardlink",
+        "sha256": "d022b623f8d0ae2b8add997eedbe80c9bffcd3c2d4cb1bb7ed3cd936d271fa9d",
+        "sha256_in_prefix": "d022b623f8d0ae2b8add997eedbe80c9bffcd3c2d4cb1bb7ed3cd936d271fa9d",
+        "size_in_bytes": 703325
+      },
+      {
+        "_path": "Lib/queue.py",
+        "path_type": "hardlink",
+        "sha256": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0",
+        "sha256_in_prefix": "f6c37fc37cd7440979f7d22d40ee818fa3b714c573610c08fa52911d541193f0",
+        "size_in_bytes": 11496
+      },
+      {
+        "_path": "Lib/quopri.py",
+        "path_type": "hardlink",
+        "sha256": "7070b61e5a582423a1bb405e3d23cb3e26c4faafcb142a8cbb88ec3f2d6104e9",
+        "sha256_in_prefix": "7070b61e5a582423a1bb405e3d23cb3e26c4faafcb142a8cbb88ec3f2d6104e9",
+        "size_in_bytes": 7268
+      },
+      {
+        "_path": "Lib/random.py",
+        "path_type": "hardlink",
+        "sha256": "e9184015f70d4c0840ae24781fab340458ea8bb9e2619c04713eaf3a9402c65a",
+        "sha256_in_prefix": "e9184015f70d4c0840ae24781fab340458ea8bb9e2619c04713eaf3a9402c65a",
+        "size_in_bytes": 31484
+      },
+      {
+        "_path": "Lib/re.py",
+        "path_type": "hardlink",
+        "sha256": "4326ef93e3cf336c06523426187dce705c12f9fdc0a562a7cd00ab1739b14c2d",
+        "sha256_in_prefix": "4326ef93e3cf336c06523426187dce705c12f9fdc0a562a7cd00ab1739b14c2d",
+        "size_in_bytes": 15861
+      },
+      {
+        "_path": "Lib/reprlib.py",
+        "path_type": "hardlink",
+        "sha256": "dc786fbc528e10bc6ea3c1fa84e4178e85c4f3c9b937a4b191546aec317e9cb9",
+        "sha256_in_prefix": "dc786fbc528e10bc6ea3c1fa84e4178e85c4f3c9b937a4b191546aec317e9cb9",
+        "size_in_bytes": 5267
+      },
+      {
+        "_path": "Lib/rlcompleter.py",
+        "path_type": "hardlink",
+        "sha256": "57f841c707924afc0e45761e52528423f6db0386d543c1ace50d904615db195d",
+        "sha256_in_prefix": "57f841c707924afc0e45761e52528423f6db0386d543c1ace50d904615db195d",
+        "size_in_bytes": 7648
+      },
+      {
+        "_path": "Lib/runpy.py",
+        "path_type": "hardlink",
+        "sha256": "d2894fc510efa7754d9a1aef5959fef7b50a4ba5f68449b2641b8b661b18a66d",
+        "sha256_in_prefix": "d2894fc510efa7754d9a1aef5959fef7b50a4ba5f68449b2641b8b661b18a66d",
+        "size_in_bytes": 13084
+      },
+      {
+        "_path": "Lib/sched.py",
+        "path_type": "hardlink",
+        "sha256": "60006f906a2aad59a81a4e4e0ca36b69088848623edc8598c0b2a41d9f30565d",
+        "sha256_in_prefix": "60006f906a2aad59a81a4e4e0ca36b69088848623edc8598c0b2a41d9f30565d",
+        "size_in_bytes": 6442
+      },
+      {
+        "_path": "Lib/secrets.py",
+        "path_type": "hardlink",
+        "sha256": "695195792d0f738bbdcd22ab0493e787d7a167adb1ac453b2b400ce4ebf66842",
+        "sha256_in_prefix": "695195792d0f738bbdcd22ab0493e787d7a167adb1ac453b2b400ce4ebf66842",
+        "size_in_bytes": 2036
+      },
+      {
+        "_path": "Lib/selectors.py",
+        "path_type": "hardlink",
+        "sha256": "b16e673c110fd6a362414308ef73ffc3c15125c87361333b309791735931040d",
+        "sha256_in_prefix": "b16e673c110fd6a362414308ef73ffc3c15125c87361333b309791735931040d",
+        "size_in_bytes": 19536
+      },
+      {
+        "_path": "Lib/shelve.py",
+        "path_type": "hardlink",
+        "sha256": "5de04545f6afbe55c51f2bedce0f5388e6fc6941f28259703342e57f8d75f885",
+        "sha256_in_prefix": "5de04545f6afbe55c51f2bedce0f5388e6fc6941f28259703342e57f8d75f885",
+        "size_in_bytes": 8527
+      },
+      {
+        "_path": "Lib/shlex.py",
+        "path_type": "hardlink",
+        "sha256": "42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7",
+        "sha256_in_prefix": "42ab6060f316e121e374e6621d8c1c98b8db323903c3df289a810c45a8ae46a7",
+        "size_in_bytes": 13501
+      },
+      {
+        "_path": "Lib/shutil.py",
+        "path_type": "hardlink",
+        "sha256": "244e9b24b36625d0ad62ee3781103264df1d34a381973d73e34e5ce86498d0d1",
+        "sha256_in_prefix": "244e9b24b36625d0ad62ee3781103264df1d34a381973d73e34e5ce86498d0d1",
+        "size_in_bytes": 53030
+      },
+      {
+        "_path": "Lib/signal.py",
+        "path_type": "hardlink",
+        "sha256": "6ae9e49fe09b607bc161fc80067de9763aa48f523567a34992f00be06057f00a",
+        "sha256_in_prefix": "6ae9e49fe09b607bc161fc80067de9763aa48f523567a34992f00be06057f00a",
+        "size_in_bytes": 2438
+      },
+      {
+        "_path": "Lib/site-packages/README.txt",
+        "path_type": "hardlink",
+        "sha256": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb",
+        "sha256_in_prefix": "cba8fece8f62c36306ba27a128f124a257710e41fc619301ee97be93586917cb",
+        "size_in_bytes": 119
+      },
+      {
+        "_path": "Lib/site.py",
+        "path_type": "hardlink",
+        "sha256": "0e29bb8f3c6a860e45eccdf7bf5615c6fe0e9f458981396034dc71460c962fbf",
+        "sha256_in_prefix": "0e29bb8f3c6a860e45eccdf7bf5615c6fe0e9f458981396034dc71460c962fbf",
+        "size_in_bytes": 21844
+      },
+      {
+        "_path": "Lib/smtpd.py",
+        "path_type": "hardlink",
+        "sha256": "822c88966d59b8f03b2749ec76850cc96b98b2f35245a67f3a09be335f209140",
+        "sha256_in_prefix": "822c88966d59b8f03b2749ec76850cc96b98b2f35245a67f3a09be335f209140",
+        "size_in_bytes": 34823
+      },
+      {
+        "_path": "Lib/smtplib.py",
+        "path_type": "hardlink",
+        "sha256": "ce708b83488f6f5cd982532579cc3b10ee8f9b7512794e66f40f82d3e8b9f2b9",
+        "sha256_in_prefix": "ce708b83488f6f5cd982532579cc3b10ee8f9b7512794e66f40f82d3e8b9f2b9",
+        "size_in_bytes": 45407
+      },
+      {
+        "_path": "Lib/sndhdr.py",
+        "path_type": "hardlink",
+        "sha256": "50770b17429ae1387cbccef9ee4e0f1f4cb43494e01079f0564bf25b62f3ee21",
+        "sha256_in_prefix": "50770b17429ae1387cbccef9ee4e0f1f4cb43494e01079f0564bf25b62f3ee21",
+        "size_in_bytes": 7099
+      },
+      {
+        "_path": "Lib/socket.py",
+        "path_type": "hardlink",
+        "sha256": "b5da4dbf86b34acc7507ebb684c03fffd805c1b4d6c46b600ec3fef003e616e3",
+        "sha256_in_prefix": "b5da4dbf86b34acc7507ebb684c03fffd805c1b4d6c46b600ec3fef003e616e3",
+        "size_in_bytes": 36915
+      },
+      {
+        "_path": "Lib/socketserver.py",
+        "path_type": "hardlink",
+        "sha256": "59007916cf2f540185bf47f3be35648d5141b9c0f4668b214900c4c35037179e",
+        "sha256_in_prefix": "59007916cf2f540185bf47f3be35648d5141b9c0f4668b214900c4c35037179e",
+        "size_in_bytes": 27296
+      },
+      {
+        "_path": "Lib/sqlite3/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "b433be7182f3646c7849f80e0459fc47b994faacb8949d8f09c87404cc4afe52",
+        "sha256_in_prefix": "b433be7182f3646c7849f80e0459fc47b994faacb8949d8f09c87404cc4afe52",
+        "size_in_bytes": 2014
+      },
+      {
+        "_path": "Lib/sqlite3/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "56fd08b0cc98e083acf76833b5f8bfdfd2e159e7cac58b2413e332d8202fe06f",
+        "sha256_in_prefix": "56fd08b0cc98e083acf76833b5f8bfdfd2e159e7cac58b2413e332d8202fe06f",
+        "size_in_bytes": 1153
+      },
+      {
+        "_path": "Lib/sqlite3/__pycache__/dbapi2.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1f07e90aece0127f169ee9a276e515d631b2f44b13b1477e4dd54a2900b229e6",
+        "sha256_in_prefix": "1f07e90aece0127f169ee9a276e515d631b2f44b13b1477e4dd54a2900b229e6",
+        "size_in_bytes": 2481
+      },
+      {
+        "_path": "Lib/sqlite3/__pycache__/dump.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "20da7493033731dfcfbc985f59407be162a256fa9f8079f86efc95d0ffeb2dca",
+        "sha256_in_prefix": "20da7493033731dfcfbc985f59407be162a256fa9f8079f86efc95d0ffeb2dca",
+        "size_in_bytes": 1906
+      },
+      {
+        "_path": "Lib/sqlite3/dbapi2.py",
+        "path_type": "hardlink",
+        "sha256": "2031e765b130d7f8a0a1984d0e09576fa9decd4009507df539bb683037ab4dd3",
+        "sha256_in_prefix": "2031e765b130d7f8a0a1984d0e09576fa9decd4009507df539bb683037ab4dd3",
+        "size_in_bytes": 2687
+      },
+      {
+        "_path": "Lib/sqlite3/dump.py",
+        "path_type": "hardlink",
+        "sha256": "b7d3eb1d97e98f2fd1420dca8f739996ca8380e7e15c732841c6f01ad4d9cfac",
+        "sha256_in_prefix": "b7d3eb1d97e98f2fd1420dca8f739996ca8380e7e15c732841c6f01ad4d9cfac",
+        "size_in_bytes": 2825
+      },
+      {
+        "_path": "Lib/sqlite3/test/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5eb422ace61254c16e3fdf53571db2229b7de1ba363ac56c2080b8cc03b09b84",
+        "sha256_in_prefix": "5eb422ace61254c16e3fdf53571db2229b7de1ba363ac56c2080b8cc03b09b84",
+        "size_in_bytes": 119
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/backup.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a66befeec424f7dd689ff465473ac283fd81c5262ff6ea5071b90441cb5535ca",
+        "sha256_in_prefix": "a66befeec424f7dd689ff465473ac283fd81c5262ff6ea5071b90441cb5535ca",
+        "size_in_bytes": 7750
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/dbapi.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "47ac147a0a3db6eb8faee07574f93935ad51a08e02fe9c9b7fd3602ecd26cb04",
+        "sha256_in_prefix": "47ac147a0a3db6eb8faee07574f93935ad51a08e02fe9c9b7fd3602ecd26cb04",
+        "size_in_bytes": 45872
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/dump.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0e08a870561de565a4a22be7f1f0be6a78dc1033952981245dee8e9a35b8c991",
+        "sha256_in_prefix": "0e08a870561de565a4a22be7f1f0be6a78dc1033952981245dee8e9a35b8c991",
+        "size_in_bytes": 3344
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/factory.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7201126843925e86a3e03605a83539212c9cd49955ab5ea7fa2a6eacf6a108b1",
+        "sha256_in_prefix": "7201126843925e86a3e03605a83539212c9cd49955ab5ea7fa2a6eacf6a108b1",
+        "size_in_bytes": 13825
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/hooks.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5e5caa8096821150c2ad21798a1fc4ad30560235c9437bce0dd39af9816d9fef",
+        "sha256_in_prefix": "5e5caa8096821150c2ad21798a1fc4ad30560235c9437bce0dd39af9816d9fef",
+        "size_in_bytes": 11769
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/regression.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5a383b707c9a395260e89789e90be2f5d663fc7c4793c372709a93d9520a5040",
+        "sha256_in_prefix": "5a383b707c9a395260e89789e90be2f5d663fc7c4793c372709a93d9520a5040",
+        "size_in_bytes": 20012
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/transactions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eba15f14826de11aab3aae20927af0cf484d6268f05cf2a025f0fb3ac7d4747b",
+        "sha256_in_prefix": "eba15f14826de11aab3aae20927af0cf484d6268f05cf2a025f0fb3ac7d4747b",
+        "size_in_bytes": 7267
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/types.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9d72116aa84eb5462616e275096c78193c9d5b687fb12389fc5cbdb617ee67de",
+        "sha256_in_prefix": "9d72116aa84eb5462616e275096c78193c9d5b687fb12389fc5cbdb617ee67de",
+        "size_in_bytes": 18398
+      },
+      {
+        "_path": "Lib/sqlite3/test/__pycache__/userfunctions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "70363923f67e494d1aaeeda02394fbfa30408ad31c121fbe07753e24f46b66ee",
+        "sha256_in_prefix": "70363923f67e494d1aaeeda02394fbfa30408ad31c121fbe07753e24f46b66ee",
+        "size_in_bytes": 23829
+      },
+      {
+        "_path": "Lib/sqlite3/test/backup.py",
+        "path_type": "hardlink",
+        "sha256": "3c17bb924a970301d0849d7fe3871de2b2553bcabd686b4636e8a74ebb878cbd",
+        "sha256_in_prefix": "3c17bb924a970301d0849d7fe3871de2b2553bcabd686b4636e8a74ebb878cbd",
+        "size_in_bytes": 5963
+      },
+      {
+        "_path": "Lib/sqlite3/test/dbapi.py",
+        "path_type": "hardlink",
+        "sha256": "ecf1a2250f0ee839a5667f53a4665db3cd3ef7c1ce358aa5e953f287c50c54cc",
+        "sha256_in_prefix": "ecf1a2250f0ee839a5667f53a4665db3cd3ef7c1ce358aa5e953f287c50c54cc",
+        "size_in_bytes": 39166
+      },
+      {
+        "_path": "Lib/sqlite3/test/dump.py",
+        "path_type": "hardlink",
+        "sha256": "faf806f5db06f747a4327bd5cda5a998d3fef27979f1b5e8a96da1fbd63c6107",
+        "sha256_in_prefix": "faf806f5db06f747a4327bd5cda5a998d3fef27979f1b5e8a96da1fbd63c6107",
+        "size_in_bytes": 2840
+      },
+      {
+        "_path": "Lib/sqlite3/test/factory.py",
+        "path_type": "hardlink",
+        "sha256": "c2caca4285525ea19340f87952af6525f8a4fa6882efcbcd08029d5ff5a0a148",
+        "sha256_in_prefix": "c2caca4285525ea19340f87952af6525f8a4fa6882efcbcd08029d5ff5a0a148",
+        "size_in_bytes": 12295
+      },
+      {
+        "_path": "Lib/sqlite3/test/hooks.py",
+        "path_type": "hardlink",
+        "sha256": "46c5f838746ec16f8ed21209315099eb989dc57c8eb9c8d1d71694ea2be55b2b",
+        "sha256_in_prefix": "46c5f838746ec16f8ed21209315099eb989dc57c8eb9c8d1d71694ea2be55b2b",
+        "size_in_bytes": 10874
+      },
+      {
+        "_path": "Lib/sqlite3/test/regression.py",
+        "path_type": "hardlink",
+        "sha256": "371de06205c9fa624815ecc6189a316f352bdab4dfefcf5327b22a549ffa63eb",
+        "sha256_in_prefix": "371de06205c9fa624815ecc6189a316f352bdab4dfefcf5327b22a549ffa63eb",
+        "size_in_bytes": 17312
+      },
+      {
+        "_path": "Lib/sqlite3/test/transactions.py",
+        "path_type": "hardlink",
+        "sha256": "e60632f50d0813c0866a8af44711c673b3cc9218f4be4a19695f99121206d615",
+        "sha256_in_prefix": "e60632f50d0813c0866a8af44711c673b3cc9218f4be4a19695f99121206d615",
+        "size_in_bytes": 7855
+      },
+      {
+        "_path": "Lib/sqlite3/test/types.py",
+        "path_type": "hardlink",
+        "sha256": "b01768fd248384a9030e7121d3066637209b82fbdc0e5611b323e15acffbf04e",
+        "sha256_in_prefix": "b01768fd248384a9030e7121d3066637209b82fbdc0e5611b323e15acffbf04e",
+        "size_in_bytes": 16473
+      },
+      {
+        "_path": "Lib/sqlite3/test/userfunctions.py",
+        "path_type": "hardlink",
+        "sha256": "262bd519181e50322fa4bd8d50e7db054b72917d3117e3ff146d9cba9e14b0f1",
+        "sha256_in_prefix": "262bd519181e50322fa4bd8d50e7db054b72917d3117e3ff146d9cba9e14b0f1",
+        "size_in_bytes": 18986
+      },
+      {
+        "_path": "Lib/sre_compile.py",
+        "path_type": "hardlink",
+        "sha256": "800f4c7df096e10336cd54f1aa6382721d6fcb974669463fe67f7a9189e52407",
+        "sha256_in_prefix": "800f4c7df096e10336cd54f1aa6382721d6fcb974669463fe67f7a9189e52407",
+        "size_in_bytes": 27973
+      },
+      {
+        "_path": "Lib/sre_constants.py",
+        "path_type": "hardlink",
+        "sha256": "6d5f1ff40e42f4be9b98899b58684dffcdb9c0ef1b3b942c17a3fcafc0bbcdc1",
+        "sha256_in_prefix": "6d5f1ff40e42f4be9b98899b58684dffcdb9c0ef1b3b942c17a3fcafc0bbcdc1",
+        "size_in_bytes": 7177
+      },
+      {
+        "_path": "Lib/sre_parse.py",
+        "path_type": "hardlink",
+        "sha256": "dad10892e970f3b9d0ad874d893edde31c0303e39ea5e2678935129e29128c2f",
+        "sha256_in_prefix": "dad10892e970f3b9d0ad874d893edde31c0303e39ea5e2678935129e29128c2f",
+        "size_in_bytes": 40779
+      },
+      {
+        "_path": "Lib/ssl.py",
+        "path_type": "hardlink",
+        "sha256": "9f11f8c322f14484403d7f564e5059b5f4146dfd57704f09dea801a6fa07d2e6",
+        "sha256_in_prefix": "9f11f8c322f14484403d7f564e5059b5f4146dfd57704f09dea801a6fa07d2e6",
+        "size_in_bytes": 52530
+      },
+      {
+        "_path": "Lib/stat.py",
+        "path_type": "hardlink",
+        "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77",
+        "sha256_in_prefix": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77",
+        "size_in_bytes": 5485
+      },
+      {
+        "_path": "Lib/statistics.py",
+        "path_type": "hardlink",
+        "sha256": "8dd0406ee8988d42bcb41577e4e45c61bf78423d5158738ce765df96b99b3c23",
+        "sha256_in_prefix": "8dd0406ee8988d42bcb41577e4e45c61bf78423d5158738ce765df96b99b3c23",
+        "size_in_bytes": 38067
+      },
+      {
+        "_path": "Lib/string.py",
+        "path_type": "hardlink",
+        "sha256": "bc57c407a8397ee2bea8683d0ce0a563a060c74c785ff36fc6555d66a9c7a566",
+        "sha256_in_prefix": "bc57c407a8397ee2bea8683d0ce0a563a060c74c785ff36fc6555d66a9c7a566",
+        "size_in_bytes": 10566
+      },
+      {
+        "_path": "Lib/stringprep.py",
+        "path_type": "hardlink",
+        "sha256": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5",
+        "sha256_in_prefix": "60b6c83581093029312efb6670b11c540090b3f78bcf72264467b494f02f21a5",
+        "size_in_bytes": 12917
+      },
+      {
+        "_path": "Lib/struct.py",
+        "path_type": "hardlink",
+        "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856",
+        "sha256_in_prefix": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "Lib/subprocess.py",
+        "path_type": "hardlink",
+        "sha256": "1d966866e1a2ea259d152b501be8ea69149eb00aca0ad32750488434c62018ef",
+        "sha256_in_prefix": "1d966866e1a2ea259d152b501be8ea69149eb00aca0ad32750488434c62018ef",
+        "size_in_bytes": 83564
+      },
+      {
+        "_path": "Lib/sunau.py",
+        "path_type": "hardlink",
+        "sha256": "6163b749f5a2afd7709eb98e2d9bc1db8811aaeb693553932841dba6b8bca537",
+        "sha256_in_prefix": "6163b749f5a2afd7709eb98e2d9bc1db8811aaeb693553932841dba6b8bca537",
+        "size_in_bytes": 18158
+      },
+      {
+        "_path": "Lib/symbol.py",
+        "path_type": "hardlink",
+        "sha256": "f01048011edabcb78c12ceff46003a899f9fca12b2dea1505510842e7ffc40aa",
+        "sha256_in_prefix": "f01048011edabcb78c12ceff46003a899f9fca12b2dea1505510842e7ffc40aa",
+        "size_in_bytes": 2281
+      },
+      {
+        "_path": "Lib/symtable.py",
+        "path_type": "hardlink",
+        "sha256": "db78e172738d423557fbd8cb031e3aba972d960ddc95c63367046e0dded01369",
+        "sha256_in_prefix": "db78e172738d423557fbd8cb031e3aba972d960ddc95c63367046e0dded01369",
+        "size_in_bytes": 7905
+      },
+      {
+        "_path": "Lib/sysconfig.py",
+        "path_type": "hardlink",
+        "sha256": "05ba1423aa84a9250efcaf8093771b484157babe8266ddf244187fa1f4b26a8d",
+        "sha256_in_prefix": "05ba1423aa84a9250efcaf8093771b484157babe8266ddf244187fa1f4b26a8d",
+        "size_in_bytes": 25286
+      },
+      {
+        "_path": "Lib/tabnanny.py",
+        "path_type": "hardlink",
+        "sha256": "45bc3914df7a1fd58d5c66fbdf6b98d89ac139e853b7d307f96c662128a4d630",
+        "sha256_in_prefix": "45bc3914df7a1fd58d5c66fbdf6b98d89ac139e853b7d307f96c662128a4d630",
+        "size_in_bytes": 11408
+      },
+      {
+        "_path": "Lib/tarfile.py",
+        "path_type": "hardlink",
+        "sha256": "c09473e386fdf32cddc1d585613dbac98af23436648728580b9718970ba5a65b",
+        "sha256_in_prefix": "c09473e386fdf32cddc1d585613dbac98af23436648728580b9718970ba5a65b",
+        "size_in_bytes": 106881
+      },
+      {
+        "_path": "Lib/telnetlib.py",
+        "path_type": "hardlink",
+        "sha256": "ea39572ed5af144022e46767c959d01d1bcb3a596b62dcfd9db6adc77cedd924",
+        "sha256_in_prefix": "ea39572ed5af144022e46767c959d01d1bcb3a596b62dcfd9db6adc77cedd924",
+        "size_in_bytes": 23254
+      },
+      {
+        "_path": "Lib/tempfile.py",
+        "path_type": "hardlink",
+        "sha256": "6f8317b2d048bbc85cdd54ac0e329c5ad33a57290ee4be39bf7f04db1daee68f",
+        "sha256_in_prefix": "6f8317b2d048bbc85cdd54ac0e329c5ad33a57290ee4be39bf7f04db1daee68f",
+        "size_in_bytes": 27963
+      },
+      {
+        "_path": "Lib/test/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9",
+        "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9",
+        "size_in_bytes": 47
+      },
+      {
+        "_path": "Lib/test/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "17add14461f45a03f5cafca4f74f01f36ab412bcb7982757239534594dd4347c",
+        "sha256_in_prefix": "17add14461f45a03f5cafca4f74f01f36ab412bcb7982757239534594dd4347c",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "Lib/test/support/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "8b8fd6252c5f301a9ec5971982bec67c8918476e93cabb3874c5b974f254c5b9",
+        "sha256_in_prefix": "8b8fd6252c5f301a9ec5971982bec67c8918476e93cabb3874c5b974f254c5b9",
+        "size_in_bytes": 112275
+      },
+      {
+        "_path": "Lib/test/support/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "18b78955eea8393133072f5d3887439fa96aea03953c18310385b863465c6f37",
+        "sha256_in_prefix": "18b78955eea8393133072f5d3887439fa96aea03953c18310385b863465c6f37",
+        "size_in_bytes": 90626
+      },
+      {
+        "_path": "Lib/test/support/__pycache__/bytecode_helper.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c5a20e10630cbcfa281d00c9b161cbcc87acc21089cc9f6c9ea2727b2f19dc08",
+        "sha256_in_prefix": "c5a20e10630cbcfa281d00c9b161cbcc87acc21089cc9f6c9ea2727b2f19dc08",
+        "size_in_bytes": 1664
+      },
+      {
+        "_path": "Lib/test/support/__pycache__/hashlib_helper.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aacbc11d92e11f6d53dbf750e48d0986afee56aefed3f535b683490ed0bbeb8c",
+        "sha256_in_prefix": "aacbc11d92e11f6d53dbf750e48d0986afee56aefed3f535b683490ed0bbeb8c",
+        "size_in_bytes": 1878
+      },
+      {
+        "_path": "Lib/test/support/__pycache__/logging_helper.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ee922203210898709bfaed3fd1439d5b6dc9435a3d4026e058a6a3c1df8a8edf",
+        "sha256_in_prefix": "ee922203210898709bfaed3fd1439d5b6dc9435a3d4026e058a6a3c1df8a8edf",
+        "size_in_bytes": 1138
+      },
+      {
+        "_path": "Lib/test/support/__pycache__/script_helper.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "02597fe72a4a074f9698e44ad2d6c8d8ccf3ca75131faa8e7285d449ff7e74d8",
+        "sha256_in_prefix": "02597fe72a4a074f9698e44ad2d6c8d8ccf3ca75131faa8e7285d449ff7e74d8",
+        "size_in_bytes": 7152
+      },
+      {
+        "_path": "Lib/test/support/__pycache__/socket_helper.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a673312a3c46ea35b971ba04977cc2308ac93b47acde1531e176d1068a831502",
+        "sha256_in_prefix": "a673312a3c46ea35b971ba04977cc2308ac93b47acde1531e176d1068a831502",
+        "size_in_bytes": 9616
+      },
+      {
+        "_path": "Lib/test/support/__pycache__/testresult.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e0639c943c796dbb1a3af13e11f9a89d7a051ff21f886462ed09220092b36d70",
+        "sha256_in_prefix": "e0639c943c796dbb1a3af13e11f9a89d7a051ff21f886462ed09220092b36d70",
+        "size_in_bytes": 6637
+      },
+      {
+        "_path": "Lib/test/support/__pycache__/warnings_helper.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0003cf924ec2f5988bbb699c0e9341655f4d8cb87a964e32160472bcdaf92b3c",
+        "sha256_in_prefix": "0003cf924ec2f5988bbb699c0e9341655f4d8cb87a964e32160472bcdaf92b3c",
+        "size_in_bytes": 6316
+      },
+      {
+        "_path": "Lib/test/support/bytecode_helper.py",
+        "path_type": "hardlink",
+        "sha256": "772773018b6e71a6accde71169cf7d666c6897cb2ea9eaa30476b64e1c32c255",
+        "sha256_in_prefix": "772773018b6e71a6accde71169cf7d666c6897cb2ea9eaa30476b64e1c32c255",
+        "size_in_bytes": 1608
+      },
+      {
+        "_path": "Lib/test/support/hashlib_helper.py",
+        "path_type": "hardlink",
+        "sha256": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12",
+        "sha256_in_prefix": "19924c427e33c86284ef2a41f76ab6937ab36f12e3d1ef4e617cdbf616a8fc12",
+        "size_in_bytes": 1907
+      },
+      {
+        "_path": "Lib/test/support/logging_helper.py",
+        "path_type": "hardlink",
+        "sha256": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3",
+        "sha256_in_prefix": "be1927e654180fcf6d84257be161fe6fa59796774e862c89b6b78adb656738f3",
+        "size_in_bytes": 916
+      },
+      {
+        "_path": "Lib/test/support/script_helper.py",
+        "path_type": "hardlink",
+        "sha256": "da237aca5be1384a212464246e0b544434c68da13b139b4b447b87123d557b81",
+        "sha256_in_prefix": "da237aca5be1384a212464246e0b544434c68da13b139b4b447b87123d557b81",
+        "size_in_bytes": 10567
+      },
+      {
+        "_path": "Lib/test/support/socket_helper.py",
+        "path_type": "hardlink",
+        "sha256": "1b6f75710b97e16a374ba952bb52cd49fd881163ea2ffc580509a9a9ceeac51c",
+        "sha256_in_prefix": "1b6f75710b97e16a374ba952bb52cd49fd881163ea2ffc580509a9a9ceeac51c",
+        "size_in_bytes": 11448
+      },
+      {
+        "_path": "Lib/test/support/testresult.py",
+        "path_type": "hardlink",
+        "sha256": "cadfcc585a449781f5737da94b288aa0d639ac201668dd7e9ba444006d5c9d8f",
+        "sha256_in_prefix": "cadfcc585a449781f5737da94b288aa0d639ac201668dd7e9ba444006d5c9d8f",
+        "size_in_bytes": 5622
+      },
+      {
+        "_path": "Lib/test/support/warnings_helper.py",
+        "path_type": "hardlink",
+        "sha256": "91af7203ff5d57fc449b0cc6c5a1433de3ce4fbd1302ce49844dd157668d543c",
+        "sha256_in_prefix": "91af7203ff5d57fc449b0cc6c5a1433de3ce4fbd1302ce49844dd157668d543c",
+        "size_in_bytes": 6605
+      },
+      {
+        "_path": "Lib/textwrap.py",
+        "path_type": "hardlink",
+        "sha256": "1c77f6f23a57bc4494c9d81d1e8d2cfb9cda241bf6d71b7db0af963ba9ad0190",
+        "sha256_in_prefix": "1c77f6f23a57bc4494c9d81d1e8d2cfb9cda241bf6d71b7db0af963ba9ad0190",
+        "size_in_bytes": 19407
+      },
+      {
+        "_path": "Lib/this.py",
+        "path_type": "hardlink",
+        "sha256": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71",
+        "sha256_in_prefix": "481d0cb3de511eae0b5713dad18542b07eafd9c013bb7690f7497bad49923a71",
+        "size_in_bytes": 1003
+      },
+      {
+        "_path": "Lib/threading.py",
+        "path_type": "hardlink",
+        "sha256": "fd5407ff42b18931d630a076a599d59aeb3cd8c0209053db51f161f51f7d59ea",
+        "sha256_in_prefix": "fd5407ff42b18931d630a076a599d59aeb3cd8c0209053db51f161f51f7d59ea",
+        "size_in_bytes": 54176
+      },
+      {
+        "_path": "Lib/timeit.py",
+        "path_type": "hardlink",
+        "sha256": "77d8b765485760e7dc5b343a87cf5b580cb6dd1c9800bb54047508190c2f5d11",
+        "sha256_in_prefix": "77d8b765485760e7dc5b343a87cf5b580cb6dd1c9800bb54047508190c2f5d11",
+        "size_in_bytes": 13482
+      },
+      {
+        "_path": "Lib/tkinter/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "182ceec989b8f13d0a9c826f3cc3236650275ee6c979768e2206ae6573e52e7c",
+        "sha256_in_prefix": "182ceec989b8f13d0a9c826f3cc3236650275ee6c979768e2206ae6573e52e7c",
+        "size_in_bytes": 169626
+      },
+      {
+        "_path": "Lib/tkinter/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e",
+        "sha256_in_prefix": "9738a6cb9cdd8139721dd82118bd527897db5325d807222883f70fb1c5a1c27e",
+        "size_in_bytes": 148
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "94b6e91bb3a415a9e7f1eb72b4c5a7fe5e627aff30b6ef1294602ea0e068d5a2",
+        "sha256_in_prefix": "94b6e91bb3a415a9e7f1eb72b4c5a7fe5e627aff30b6ef1294602ea0e068d5a2",
+        "size_in_bytes": 176035
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ac19464d02b5451e692a33bde17c24e0319e247bfc142ff6db9e9abc0242d159",
+        "sha256_in_prefix": "ac19464d02b5451e692a33bde17c24e0319e247bfc142ff6db9e9abc0242d159",
+        "size_in_bytes": 289
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/colorchooser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d24557e74139642241c8207994e55b3869a97a7255d31a9e6550e4096224a02e",
+        "sha256_in_prefix": "d24557e74139642241c8207994e55b3869a97a7255d31a9e6550e4096224a02e",
+        "size_in_bytes": 2258
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/commondialog.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b00bb16433c6657b06372581a1231134bfb630c612bc911ff6232d4d97374856",
+        "sha256_in_prefix": "b00bb16433c6657b06372581a1231134bfb630c612bc911ff6232d4d97374856",
+        "size_in_bytes": 1161
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/constants.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ccb50dfa196ccdc10cf21b5da4d9a73cabda258e85e6bfc3a5e7904d87a391ad",
+        "sha256_in_prefix": "ccb50dfa196ccdc10cf21b5da4d9a73cabda258e85e6bfc3a5e7904d87a391ad",
+        "size_in_bytes": 1639
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/dialog.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b68b9a029a14749d5f0b08a4d4e87855d575cc906c27d515280324663d43ec2f",
+        "sha256_in_prefix": "b68b9a029a14749d5f0b08a4d4e87855d575cc906c27d515280324663d43ec2f",
+        "size_in_bytes": 1482
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/dnd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6b791fed761ecc4d75d436a0a8c329161ab437c39319385290d9107b671618be",
+        "sha256_in_prefix": "6b791fed761ecc4d75d436a0a8c329161ab437c39319385290d9107b671618be",
+        "size_in_bytes": 11270
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/filedialog.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b59d3afd08cdbf0bc2e5ecebd808291000b394d648fe537837d634db87f2ba64",
+        "sha256_in_prefix": "b59d3afd08cdbf0bc2e5ecebd808291000b394d648fe537837d634db87f2ba64",
+        "size_in_bytes": 12601
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/font.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a11dfe26f52aa734ee377628cc0250364bbd8286d29eb78d31df97363b363fcd",
+        "sha256_in_prefix": "a11dfe26f52aa734ee377628cc0250364bbd8286d29eb78d31df97363b363fcd",
+        "size_in_bytes": 6365
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/messagebox.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e68e6d9790f49029c19faba45402dc5487e6191c2c7bdaae564d482f901bff96",
+        "sha256_in_prefix": "e68e6d9790f49029c19faba45402dc5487e6191c2c7bdaae564d482f901bff96",
+        "size_in_bytes": 3065
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/scrolledtext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "093a614b6a93c2b06bf70d7b21b2e2802be60fbd7aa04ac4efba13a7b8ca334d",
+        "sha256_in_prefix": "093a614b6a93c2b06bf70d7b21b2e2802be60fbd7aa04ac4efba13a7b8ca334d",
+        "size_in_bytes": 2166
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/simpledialog.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3fc3acbf3301e8d3cd959121583d7fcfcae8c23bfe57a4845922e8373b146dcd",
+        "sha256_in_prefix": "3fc3acbf3301e8d3cd959121583d7fcfcae8c23bfe57a4845922e8373b146dcd",
+        "size_in_bytes": 10993
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/tix.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "68817ce3e9d41299f338bf7f1ef58b9011527005a21dc94abd82bfc03414b5fd",
+        "sha256_in_prefix": "68817ce3e9d41299f338bf7f1ef58b9011527005a21dc94abd82bfc03414b5fd",
+        "size_in_bytes": 79250
+      },
+      {
+        "_path": "Lib/tkinter/__pycache__/ttk.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "99f890c6b0e7e9efd4022ad7754813bd39cfc2c62c387c173a53ea1faba575b9",
+        "sha256_in_prefix": "99f890c6b0e7e9efd4022ad7754813bd39cfc2c62c387c173a53ea1faba575b9",
+        "size_in_bytes": 56863
+      },
+      {
+        "_path": "Lib/tkinter/colorchooser.py",
+        "path_type": "hardlink",
+        "sha256": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143",
+        "sha256_in_prefix": "1224241dcfb4ec6aff3cafc66adeb2b2a3759397a28693173915458c50040143",
+        "size_in_bytes": 2660
+      },
+      {
+        "_path": "Lib/tkinter/commondialog.py",
+        "path_type": "hardlink",
+        "sha256": "ad0704ca101ba77d654ae42b3f79d3d3c00464f3ae61f89d746de18382b7b32b",
+        "sha256_in_prefix": "ad0704ca101ba77d654ae42b3f79d3d3c00464f3ae61f89d746de18382b7b32b",
+        "size_in_bytes": 1245
+      },
+      {
+        "_path": "Lib/tkinter/constants.py",
+        "path_type": "hardlink",
+        "sha256": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2",
+        "sha256_in_prefix": "c01314dc51d1c8effeba2528720a65da133596d4143200c68595c02067bf1da2",
+        "size_in_bytes": 1493
+      },
+      {
+        "_path": "Lib/tkinter/dialog.py",
+        "path_type": "hardlink",
+        "sha256": "6de395b4c6bf2ccb9e2c902fef4a275acf60826f6917d25477eee334812cbdd1",
+        "sha256_in_prefix": "6de395b4c6bf2ccb9e2c902fef4a275acf60826f6917d25477eee334812cbdd1",
+        "size_in_bytes": 1543
+      },
+      {
+        "_path": "Lib/tkinter/dnd.py",
+        "path_type": "hardlink",
+        "sha256": "a946a28308ecbe6534f35e9452154dc3cd987fe8c1dd2efe2c0626fa04b2172a",
+        "sha256_in_prefix": "a946a28308ecbe6534f35e9452154dc3cd987fe8c1dd2efe2c0626fa04b2172a",
+        "size_in_bytes": 11528
+      },
+      {
+        "_path": "Lib/tkinter/filedialog.py",
+        "path_type": "hardlink",
+        "sha256": "77a7a130572c2f0351f1f0dec0db4e7ac9e71970b74dfcb6c2d93b66da869df6",
+        "sha256_in_prefix": "77a7a130572c2f0351f1f0dec0db4e7ac9e71970b74dfcb6c2d93b66da869df6",
+        "size_in_bytes": 14947
+      },
+      {
+        "_path": "Lib/tkinter/font.py",
+        "path_type": "hardlink",
+        "sha256": "cb83534ba23591c6906962173b3533e9433669c04657595a726b026c76bb96f2",
+        "sha256_in_prefix": "cb83534ba23591c6906962173b3533e9433669c04657595a726b026c76bb96f2",
+        "size_in_bytes": 6821
+      },
+      {
+        "_path": "Lib/tkinter/messagebox.py",
+        "path_type": "hardlink",
+        "sha256": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63",
+        "sha256_in_prefix": "cdbf655c66778a19f0e25754a5f198a850c8bd958ce651e8fe4b2b52ad7f9c63",
+        "size_in_bytes": 3861
+      },
+      {
+        "_path": "Lib/tkinter/scrolledtext.py",
+        "path_type": "hardlink",
+        "sha256": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f",
+        "sha256_in_prefix": "c7cc050ec9cc3cc6a47215b5bc79b2d3e5c6ed895a4300ab0e20f6c249385e3f",
+        "size_in_bytes": 1816
+      },
+      {
+        "_path": "Lib/tkinter/simpledialog.py",
+        "path_type": "hardlink",
+        "sha256": "b024697e960fd7d532613df1841c35b083fe77c7eb7085ba0fed3e824da3f54c",
+        "sha256_in_prefix": "b024697e960fd7d532613df1841c35b083fe77c7eb7085ba0fed3e824da3f54c",
+        "size_in_bytes": 11757
+      },
+      {
+        "_path": "Lib/tkinter/test/README",
+        "path_type": "hardlink",
+        "sha256": "fe3c79d5da8616ca37f7a9d8fddaac2c9164b593c7b116580aa99690a5f59ab5",
+        "sha256_in_prefix": "fe3c79d5da8616ca37f7a9d8fddaac2c9164b593c7b116580aa99690a5f59ab5",
+        "size_in_bytes": 566
+      },
+      {
+        "_path": "Lib/tkinter/test/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/tkinter/test/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1fd3a3b5a325e2f3fd171e2b8ccfe10adf8951121d4c7c5809f3c1a59a3d4c22",
+        "sha256_in_prefix": "1fd3a3b5a325e2f3fd171e2b8ccfe10adf8951121d4c7c5809f3c1a59a3d4c22",
+        "size_in_bytes": 119
+      },
+      {
+        "_path": "Lib/tkinter/test/__pycache__/support.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f38cd23b4905806bfc7fb0e9bd2566c02e97dd61db884e8ca6c152bdbd4f076e",
+        "sha256_in_prefix": "f38cd23b4905806bfc7fb0e9bd2566c02e97dd61db884e8ca6c152bdbd4f076e",
+        "size_in_bytes": 4889
+      },
+      {
+        "_path": "Lib/tkinter/test/__pycache__/widget_tests.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2a446d692c78e8621c79e6eb76362e9088b0a328de3ec8768ebdbaf6843f19c6",
+        "sha256_in_prefix": "2a446d692c78e8621c79e6eb76362e9088b0a328de3ec8768ebdbaf6843f19c6",
+        "size_in_bytes": 22386
+      },
+      {
+        "_path": "Lib/tkinter/test/support.py",
+        "path_type": "hardlink",
+        "sha256": "6c7848237d490c5704d8bfa47e0bed091c5171eccebfbabc783f3846b5aa57ad",
+        "sha256_in_prefix": "6c7848237d490c5704d8bfa47e0bed091c5171eccebfbabc783f3846b5aa57ad",
+        "size_in_bytes": 4589
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3fe9919303119c89e3b1e7576e23e65a9e2e3c9194d2af71a5665f7e121e15ef",
+        "sha256_in_prefix": "3fe9919303119c89e3b1e7576e23e65a9e2e3c9194d2af71a5665f7e121e15ef",
+        "size_in_bytes": 132
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_colorchooser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5c755f5fc0000d0ac0d3ec118e6e9b8790774c28fc8f439e0efdf5fcd1c58849",
+        "sha256_in_prefix": "5c755f5fc0000d0ac0d3ec118e6e9b8790774c28fc8f439e0efdf5fcd1c58849",
+        "size_in_bytes": 1492
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_font.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5739b1b84caa9183094bbca7a152c541ea32a1469f2a50d737f7469538e8e633",
+        "sha256_in_prefix": "5739b1b84caa9183094bbca7a152c541ea32a1469f2a50d737f7469538e8e633",
+        "size_in_bytes": 4773
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_geometry_managers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "826a63147112e8ddf810eef202ad87859115ecb76740a8479e400bd5d2427cc2",
+        "sha256_in_prefix": "826a63147112e8ddf810eef202ad87859115ecb76740a8479e400bd5d2427cc2",
+        "size_in_bytes": 32719
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_images.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1dec64b995a78410913541b6df7fa2036144063c4530691ba5848fbfb2144da7",
+        "sha256_in_prefix": "1dec64b995a78410913541b6df7fa2036144063c4530691ba5848fbfb2144da7",
+        "size_in_bytes": 14432
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_loadtk.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8ddebdd760695efff3159e8d07aebcf9e585a99e9a6fc5198555bf9cf8c315e8",
+        "sha256_in_prefix": "8ddebdd760695efff3159e8d07aebcf9e585a99e9a6fc5198555bf9cf8c315e8",
+        "size_in_bytes": 1400
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_misc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c644b5212c95597b25dad8c9be9c929377b51a66c595cc2f916e48e73738845a",
+        "sha256_in_prefix": "c644b5212c95597b25dad8c9be9c929377b51a66c595cc2f916e48e73738845a",
+        "size_in_bytes": 9979
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_simpledialog.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "96a5335e9a08fefc1f7547d7d58fcaf66310040992e92cdca54a032dc1d0bddd",
+        "sha256_in_prefix": "96a5335e9a08fefc1f7547d7d58fcaf66310040992e92cdca54a032dc1d0bddd",
+        "size_in_bytes": 1144
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_text.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "42cc2973f3981fc5b07ccdff9b9d712b09ea35b6216e0cd880985bd054ab8850",
+        "sha256_in_prefix": "42cc2973f3981fc5b07ccdff9b9d712b09ea35b6216e0cd880985bd054ab8850",
+        "size_in_bytes": 1409
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_variables.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aa2fb2a28f3301989231782b5ad4d91f688153b9153632de0a89e16ec287b0d7",
+        "sha256_in_prefix": "aa2fb2a28f3301989231782b5ad4d91f688153b9153632de0a89e16ec287b0d7",
+        "size_in_bytes": 11381
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/__pycache__/test_widgets.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "06d70e47abb7e197e0db3ba008da45583ba111521bb814660ff1d6d0e59f6da3",
+        "sha256_in_prefix": "06d70e47abb7e197e0db3ba008da45583ba111521bb814660ff1d6d0e59f6da3",
+        "size_in_bytes": 50660
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_colorchooser.py",
+        "path_type": "hardlink",
+        "sha256": "8bf2e45e27f8dd04b9d32e769a61703d4c518e10c975da16d771033413ff58ee",
+        "sha256_in_prefix": "8bf2e45e27f8dd04b9d32e769a61703d4c518e10c975da16d771033413ff58ee",
+        "size_in_bytes": 1306
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_font.py",
+        "path_type": "hardlink",
+        "sha256": "93a08ffbcb8436e7973bf07bb73b4653fdd50fa082808966bab71c96960535e8",
+        "sha256_in_prefix": "93a08ffbcb8436e7973bf07bb73b4653fdd50fa082808966bab71c96960535e8",
+        "size_in_bytes": 5251
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_geometry_managers.py",
+        "path_type": "hardlink",
+        "sha256": "503cee89ea7c78c4df4107ebd5f3b99d095c8b0cb131f76e03f4f54103638e24",
+        "sha256_in_prefix": "503cee89ea7c78c4df4107ebd5f3b99d095c8b0cb131f76e03f4f54103638e24",
+        "size_in_bytes": 41015
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_images.py",
+        "path_type": "hardlink",
+        "sha256": "9c60547d1ac8a7e5ab633e3b2a87f6e6eed138319078b7ea71b801a0fb7dc4b7",
+        "sha256_in_prefix": "9c60547d1ac8a7e5ab633e3b2a87f6e6eed138319078b7ea71b801a0fb7dc4b7",
+        "size_in_bytes": 15422
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_loadtk.py",
+        "path_type": "hardlink",
+        "sha256": "36f2e5ae87693942d0ab8ee5fb884d42e70655af8fb20486212bed2ca5282314",
+        "sha256_in_prefix": "36f2e5ae87693942d0ab8ee5fb884d42e70655af8fb20486212bed2ca5282314",
+        "size_in_bytes": 1454
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_misc.py",
+        "path_type": "hardlink",
+        "sha256": "08c049456e8a28948144837348ab545e19fa43ee772dd2386c902b2b4da29368",
+        "sha256_in_prefix": "08c049456e8a28948144837348ab545e19fa43ee772dd2386c902b2b4da29368",
+        "size_in_bytes": 12819
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_simpledialog.py",
+        "path_type": "hardlink",
+        "sha256": "6c5d6b604d587cdceef09cf0d028bf21c2dbcc874b8d54b65cf0d64102f39654",
+        "sha256_in_prefix": "6c5d6b604d587cdceef09cf0d028bf21c2dbcc874b8d54b65cf0d64102f39654",
+        "size_in_bytes": 725
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_text.py",
+        "path_type": "hardlink",
+        "sha256": "803cd951903bf079464d1c09555ea3d2ec7c33746759b810c4c04311b6d2cbd1",
+        "sha256_in_prefix": "803cd951903bf079464d1c09555ea3d2ec7c33746759b810c4c04311b6d2cbd1",
+        "size_in_bytes": 1393
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_variables.py",
+        "path_type": "hardlink",
+        "sha256": "267ee87e14e5e30f904843e06f75915b4814a74077669968124e76ab80c614f9",
+        "sha256_in_prefix": "267ee87e14e5e30f904843e06f75915b4814a74077669968124e76ab80c614f9",
+        "size_in_bytes": 10801
+      },
+      {
+        "_path": "Lib/tkinter/test/test_tkinter/test_widgets.py",
+        "path_type": "hardlink",
+        "sha256": "8829963243a05d643652d7468ca73fefb6891899973e0def658666ad4fb2b1cc",
+        "sha256_in_prefix": "8829963243a05d643652d7468ca73fefb6891899973e0def658666ad4fb2b1cc",
+        "size_in_bytes": 51762
+      },
+      {
+        "_path": "Lib/tkinter/test/test_ttk/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/tkinter/test/test_ttk/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "78776225ff4d0d7d8bf77eeafa9c9f88edf12cbaaa22b357f9d236375256fbd5",
+        "sha256_in_prefix": "78776225ff4d0d7d8bf77eeafa9c9f88edf12cbaaa22b357f9d236375256fbd5",
+        "size_in_bytes": 128
+      },
+      {
+        "_path": "Lib/tkinter/test/test_ttk/__pycache__/test_extensions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a91478b42c724c6c0a6733b1fc48bf94384477ad2c7405fac8d581c46b39ea41",
+        "sha256_in_prefix": "a91478b42c724c6c0a6733b1fc48bf94384477ad2c7405fac8d581c46b39ea41",
+        "size_in_bytes": 8734
+      },
+      {
+        "_path": "Lib/tkinter/test/test_ttk/__pycache__/test_style.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "57fec13bfdc20c217559d5d9e1a641eae050c962cfc8473257e1770df8a4f0d3",
+        "sha256_in_prefix": "57fec13bfdc20c217559d5d9e1a641eae050c962cfc8473257e1770df8a4f0d3",
+        "size_in_bytes": 4884
+      },
+      {
+        "_path": "Lib/tkinter/test/test_ttk/__pycache__/test_widgets.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d6febf2c15c324945a04bfa77c1cc47ca7cbc4750bcb0653e79274ab92bce513",
+        "sha256_in_prefix": "d6febf2c15c324945a04bfa77c1cc47ca7cbc4750bcb0653e79274ab92bce513",
+        "size_in_bytes": 53329
+      },
+      {
+        "_path": "Lib/tkinter/test/test_ttk/test_extensions.py",
+        "path_type": "hardlink",
+        "sha256": "bf7ade2ab960fc224eee5b58567c2a16025fd1ab1d3e85a697c2c00f50f0ed84",
+        "sha256_in_prefix": "bf7ade2ab960fc224eee5b58567c2a16025fd1ab1d3e85a697c2c00f50f0ed84",
+        "size_in_bytes": 11940
+      },
+      {
+        "_path": "Lib/tkinter/test/test_ttk/test_style.py",
+        "path_type": "hardlink",
+        "sha256": "9d5f9a2b53e77d60b6c8eaffabf4f7fa2eb6affdc4e3bad36ce403dfd1e21606",
+        "sha256_in_prefix": "9d5f9a2b53e77d60b6c8eaffabf4f7fa2eb6affdc4e3bad36ce403dfd1e21606",
+        "size_in_bytes": 6900
+      },
+      {
+        "_path": "Lib/tkinter/test/test_ttk/test_widgets.py",
+        "path_type": "hardlink",
+        "sha256": "75cf8878de888073e63f2a244467a716660066fca7d353968eb1e3be785a9d47",
+        "sha256_in_prefix": "75cf8878de888073e63f2a244467a716660066fca7d353968eb1e3be785a9d47",
+        "size_in_bytes": 68754
+      },
+      {
+        "_path": "Lib/tkinter/test/widget_tests.py",
+        "path_type": "hardlink",
+        "sha256": "4d1d5ba5a64caac6b25ad98dbb77775b70eddafe890e5eb07123d278a163a6ed",
+        "sha256_in_prefix": "4d1d5ba5a64caac6b25ad98dbb77775b70eddafe890e5eb07123d278a163a6ed",
+        "size_in_bytes": 20380
+      },
+      {
+        "_path": "Lib/tkinter/tix.py",
+        "path_type": "hardlink",
+        "sha256": "98c3ff4d80beaf0c2d2e3cd77c1a9269069a1b0ece6ff8e84066c66a9be9e2ba",
+        "sha256_in_prefix": "98c3ff4d80beaf0c2d2e3cd77c1a9269069a1b0ece6ff8e84066c66a9be9e2ba",
+        "size_in_bytes": 76845
+      },
+      {
+        "_path": "Lib/tkinter/ttk.py",
+        "path_type": "hardlink",
+        "sha256": "f8f8940b35859f120c3ace9d3b65266140bc79de1bec2c7b175e945f016d18ed",
+        "sha256_in_prefix": "f8f8940b35859f120c3ace9d3b65266140bc79de1bec2c7b175e945f016d18ed",
+        "size_in_bytes": 57139
+      },
+      {
+        "_path": "Lib/token.py",
+        "path_type": "hardlink",
+        "sha256": "ab560a77c64094e898048757f3c62a72de40413a78f6c42f4988338a24afa6d8",
+        "sha256_in_prefix": "ab560a77c64094e898048757f3c62a72de40413a78f6c42f4988338a24afa6d8",
+        "size_in_bytes": 2368
+      },
+      {
+        "_path": "Lib/tokenize.py",
+        "path_type": "hardlink",
+        "sha256": "02905e529298418e6e6097b739960ce3055d4f7393ced7d18a10c6a3a08c6323",
+        "sha256_in_prefix": "02905e529298418e6e6097b739960ce3055d4f7393ced7d18a10c6a3a08c6323",
+        "size_in_bytes": 25883
+      },
+      {
+        "_path": "Lib/trace.py",
+        "path_type": "hardlink",
+        "sha256": "75c8ef7524a5c017a7e58218c0be12d1dfddd105f43b54cb04d0d047dd0bbc79",
+        "sha256_in_prefix": "75c8ef7524a5c017a7e58218c0be12d1dfddd105f43b54cb04d0d047dd0bbc79",
+        "size_in_bytes": 29208
+      },
+      {
+        "_path": "Lib/traceback.py",
+        "path_type": "hardlink",
+        "sha256": "d3a9173e86a21f2b64003322e8ccd55f8fe093e5ccd47aee18131b25669fad34",
+        "sha256_in_prefix": "d3a9173e86a21f2b64003322e8ccd55f8fe093e5ccd47aee18131b25669fad34",
+        "size_in_bytes": 24660
+      },
+      {
+        "_path": "Lib/tracemalloc.py",
+        "path_type": "hardlink",
+        "sha256": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25",
+        "sha256_in_prefix": "c2cc84a05b824df79840c98729a0e94ef8909b11c528a1b2c5a00aa436b97b25",
+        "size_in_bytes": 18047
+      },
+      {
+        "_path": "Lib/tty.py",
+        "path_type": "hardlink",
+        "sha256": "066a541e6d38ead952d63cc32afbac51a33acf354799f235c582eab17488105d",
+        "sha256_in_prefix": "066a541e6d38ead952d63cc32afbac51a33acf354799f235c582eab17488105d",
+        "size_in_bytes": 879
+      },
+      {
+        "_path": "Lib/turtle.py",
+        "path_type": "hardlink",
+        "sha256": "fd87a4dad42efda9ed3553d226f229b5c3725f5e6c8805831864640d9b628fd1",
+        "sha256_in_prefix": "fd87a4dad42efda9ed3553d226f229b5c3725f5e6c8805831864640d9b628fd1",
+        "size_in_bytes": 143796
+      },
+      {
+        "_path": "Lib/turtledemo/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1",
+        "sha256_in_prefix": "5f465277c96c107a5af544b0a962561f97cb0bfd75906d9bf9741450ed02b0e1",
+        "size_in_bytes": 314
+      },
+      {
+        "_path": "Lib/turtledemo/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "6608b2ef9db6022c3088651dc0f6fc1206e7ddcc466186e44ab7a8d86341dbb9",
+        "sha256_in_prefix": "6608b2ef9db6022c3088651dc0f6fc1206e7ddcc466186e44ab7a8d86341dbb9",
+        "size_in_bytes": 15050
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8b9371386cefb00bab3968d82f6fd8c92caa8844a09d1185966c7fd8bb9f5c15",
+        "sha256_in_prefix": "8b9371386cefb00bab3968d82f6fd8c92caa8844a09d1185966c7fd8bb9f5c15",
+        "size_in_bytes": 439
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7538347c04254735c5b3a4c745210d063a0afc6f95a14a156cc5073e2d09d656",
+        "sha256_in_prefix": "7538347c04254735c5b3a4c745210d063a0afc6f95a14a156cc5073e2d09d656",
+        "size_in_bytes": 13284
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/bytedesign.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f379d3db06185bb742b0b85b6a1a525dcd90f5d132b70fb62796e40d57791998",
+        "sha256_in_prefix": "f379d3db06185bb742b0b85b6a1a525dcd90f5d132b70fb62796e40d57791998",
+        "size_in_bytes": 4248
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/chaos.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c2e5c2398a5e7e130baf1d5cbb1fd9db760a62bf1e20e2c4a14badf5254b4d6c",
+        "sha256_in_prefix": "c2e5c2398a5e7e130baf1d5cbb1fd9db760a62bf1e20e2c4a14badf5254b4d6c",
+        "size_in_bytes": 1695
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/clock.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4bdbcda34cddc224d1d9d5700c95a9b7e9c4082b6683cc72fe1f61790e7fa65d",
+        "sha256_in_prefix": "4bdbcda34cddc224d1d9d5700c95a9b7e9c4082b6683cc72fe1f61790e7fa65d",
+        "size_in_bytes": 3420
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/colormixer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "997bd0bdeff217af4f16eab6e9a04db62a063fca2037b27752091477ced2eef4",
+        "sha256_in_prefix": "997bd0bdeff217af4f16eab6e9a04db62a063fca2037b27752091477ced2eef4",
+        "size_in_bytes": 1818
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/forest.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "83e0c394ddcc1b0f6181631df88838ac87b74e76424401955dd7511b4a7a2692",
+        "sha256_in_prefix": "83e0c394ddcc1b0f6181631df88838ac87b74e76424401955dd7511b4a7a2692",
+        "size_in_bytes": 3306
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/fractalcurves.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "13969ce1ac24a47f5c05b25d53250d22a2f2ebb18ff214970e6ed484099f149e",
+        "sha256_in_prefix": "13969ce1ac24a47f5c05b25d53250d22a2f2ebb18ff214970e6ed484099f149e",
+        "size_in_bytes": 2872
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/lindenmayer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1bf08043e6f87d0f8e5e0f0c9411e6f54450577c1c9e803f9300cdc32d5d6056",
+        "sha256_in_prefix": "1bf08043e6f87d0f8e5e0f0c9411e6f54450577c1c9e803f9300cdc32d5d6056",
+        "size_in_bytes": 2795
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/minimal_hanoi.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "13bf9970b15cb2fef59bac7a79ea4ed26ab4a94843774c6c4c35af6cf1d843f1",
+        "sha256_in_prefix": "13bf9970b15cb2fef59bac7a79ea4ed26ab4a94843774c6c4c35af6cf1d843f1",
+        "size_in_bytes": 2800
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/nim.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd4e2b6c8b651d35a88d8d1136e6dd0d63b28a7c724ffe44e1168efd6def8fc4",
+        "sha256_in_prefix": "dd4e2b6c8b651d35a88d8d1136e6dd0d63b28a7c724ffe44e1168efd6def8fc4",
+        "size_in_bytes": 7337
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/paint.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3bb889bff6f9ecad9b940bb2b4ef98040d0f078722c262f65bdfa272461910c7",
+        "sha256_in_prefix": "3bb889bff6f9ecad9b940bb2b4ef98040d0f078722c262f65bdfa272461910c7",
+        "size_in_bytes": 1614
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/peace.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ed73fad6760c2d9c5c0a4b98448fd0eaf8074119df89f5d25f41771432137105",
+        "sha256_in_prefix": "ed73fad6760c2d9c5c0a4b98448fd0eaf8074119df89f5d25f41771432137105",
+        "size_in_bytes": 1103
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/penrose.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dfcc037edaa372f6c9690c250c78c487a9b74291aacdd455f30717f3fa96d37d",
+        "sha256_in_prefix": "dfcc037edaa372f6c9690c250c78c487a9b74291aacdd455f30717f3fa96d37d",
+        "size_in_bytes": 4641
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/planet_and_moon.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2475db98b4e3ae01567dd53df07bb48d32cc0a86ec6dd467be0189f7059121ea",
+        "sha256_in_prefix": "2475db98b4e3ae01567dd53df07bb48d32cc0a86ec6dd467be0189f7059121ea",
+        "size_in_bytes": 3469
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/rosette.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a9a1cd98325026206ca542b57d2eab21dcb2f971947c2d6b1af118782ca01df0",
+        "sha256_in_prefix": "a9a1cd98325026206ca542b57d2eab21dcb2f971947c2d6b1af118782ca01df0",
+        "size_in_bytes": 1683
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/round_dance.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "05b108cffb4478bff750105ca02dfa9178e7a90d3e32fd4b703e93ce663af079",
+        "sha256_in_prefix": "05b108cffb4478bff750105ca02dfa9178e7a90d3e32fd4b703e93ce663af079",
+        "size_in_bytes": 1888
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/sorting_animate.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "56f74ceed84e4a05e13c5458783924a9bf6293266cedb3a965f01e6903c01e9c",
+        "sha256_in_prefix": "56f74ceed84e4a05e13c5458783924a9bf6293266cedb3a965f01e6903c01e9c",
+        "size_in_bytes": 6351
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/tree.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ae20ac61cde67fc3cdda247bc01ade63712654ef6a1945652ed468a6d75fc053",
+        "sha256_in_prefix": "ae20ac61cde67fc3cdda247bc01ade63712654ef6a1945652ed468a6d75fc053",
+        "size_in_bytes": 1710
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/two_canvases.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e1b4bcaff7d40284863a59e2aa3c5850d2c0577bcddda93d3218347c68a5d990",
+        "sha256_in_prefix": "e1b4bcaff7d40284863a59e2aa3c5850d2c0577bcddda93d3218347c68a5d990",
+        "size_in_bytes": 1249
+      },
+      {
+        "_path": "Lib/turtledemo/__pycache__/yinyang.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3f1754e926fd2209d7e4ff7f84394562e55a249fec47f8e9b54e0321f2b0b53d",
+        "sha256_in_prefix": "3f1754e926fd2209d7e4ff7f84394562e55a249fec47f8e9b54e0321f2b0b53d",
+        "size_in_bytes": 1052
+      },
+      {
+        "_path": "Lib/turtledemo/bytedesign.py",
+        "path_type": "hardlink",
+        "sha256": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f",
+        "sha256_in_prefix": "6deeee99e0ddb4ed29a648f95d4d33e9f3292c21dbecec301337c22a605a280f",
+        "size_in_bytes": 4248
+      },
+      {
+        "_path": "Lib/turtledemo/chaos.py",
+        "path_type": "hardlink",
+        "sha256": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5",
+        "sha256_in_prefix": "bc8a3a9b77e90446fb7060ff68ee008ffd6b23b366052207ec225cc163b4dae5",
+        "size_in_bytes": 951
+      },
+      {
+        "_path": "Lib/turtledemo/clock.py",
+        "path_type": "hardlink",
+        "sha256": "c8be77115c8eeee870f4865e52d1fd7496cfe81b099872a1f77650e6b3564bd3",
+        "sha256_in_prefix": "c8be77115c8eeee870f4865e52d1fd7496cfe81b099872a1f77650e6b3564bd3",
+        "size_in_bytes": 3201
+      },
+      {
+        "_path": "Lib/turtledemo/colormixer.py",
+        "path_type": "hardlink",
+        "sha256": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374",
+        "sha256_in_prefix": "bbb065830edb37fd53b1c004118853176fd8da32ee532cb0d363960880920374",
+        "size_in_bytes": 1339
+      },
+      {
+        "_path": "Lib/turtledemo/forest.py",
+        "path_type": "hardlink",
+        "sha256": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b",
+        "sha256_in_prefix": "68cd81b7da35ca49d9066cc2cba24768cddbf90797dbd619a559cf899cde926b",
+        "size_in_bytes": 2966
+      },
+      {
+        "_path": "Lib/turtledemo/fractalcurves.py",
+        "path_type": "hardlink",
+        "sha256": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320",
+        "sha256_in_prefix": "29fadf34c5eabda4649848d052fa2ed3ae829e55bc3ac5933f2aedf3fb04b320",
+        "size_in_bytes": 3473
+      },
+      {
+        "_path": "Lib/turtledemo/lindenmayer.py",
+        "path_type": "hardlink",
+        "sha256": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e",
+        "sha256_in_prefix": "4b597f52c1cb35ae8ed540d1db2dab52276c7874febd7a659ee50f26be26f61e",
+        "size_in_bytes": 2434
+      },
+      {
+        "_path": "Lib/turtledemo/minimal_hanoi.py",
+        "path_type": "hardlink",
+        "sha256": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5",
+        "sha256_in_prefix": "0e458a6257fb5a4ecd2785962850fa87924b23d4ead8aebb70aab38904ff8ef5",
+        "size_in_bytes": 2051
+      },
+      {
+        "_path": "Lib/turtledemo/nim.py",
+        "path_type": "hardlink",
+        "sha256": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3",
+        "sha256_in_prefix": "939d1ee904a7b00579bb44719b0286e7524bf560c7ffff6d482064b41b09fdb3",
+        "size_in_bytes": 6513
+      },
+      {
+        "_path": "Lib/turtledemo/paint.py",
+        "path_type": "hardlink",
+        "sha256": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e",
+        "sha256_in_prefix": "81aa22d0da1d934cb47edfef1883f9fe8ef864c56d484f79f9ec4b46457d047e",
+        "size_in_bytes": 1291
+      },
+      {
+        "_path": "Lib/turtledemo/peace.py",
+        "path_type": "hardlink",
+        "sha256": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814",
+        "sha256_in_prefix": "b260b857164684b3065ad760fec0245ab6505c220814fb179a3d080f2bba0814",
+        "size_in_bytes": 1066
+      },
+      {
+        "_path": "Lib/turtledemo/penrose.py",
+        "path_type": "hardlink",
+        "sha256": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a",
+        "sha256_in_prefix": "14aeb10db966bfd4ec923a19eb96892eb2aa2723c0962c0824fe2ca9f30e300a",
+        "size_in_bytes": 3380
+      },
+      {
+        "_path": "Lib/turtledemo/planet_and_moon.py",
+        "path_type": "hardlink",
+        "sha256": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609",
+        "sha256_in_prefix": "cd2c5344b67dbe781cf4c7f0f1eb1b97e6d8a5bf50329bdaa4e42e7d390ea609",
+        "size_in_bytes": 2825
+      },
+      {
+        "_path": "Lib/turtledemo/rosette.py",
+        "path_type": "hardlink",
+        "sha256": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0",
+        "sha256_in_prefix": "61dfd5bb932cc5a0c3bb9caa8ed74889a19a8d3ee3cb6707ea8f63595ec350b0",
+        "size_in_bytes": 1361
+      },
+      {
+        "_path": "Lib/turtledemo/round_dance.py",
+        "path_type": "hardlink",
+        "sha256": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276",
+        "sha256_in_prefix": "4ecaac02e68f11ec1a406a6ce8a4b17e4f8af74f76157e0776360d0dd041f276",
+        "size_in_bytes": 1804
+      },
+      {
+        "_path": "Lib/turtledemo/sorting_animate.py",
+        "path_type": "hardlink",
+        "sha256": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254",
+        "sha256_in_prefix": "a82a7608d3620cd8a956d3335bddbc2e30320486645de5d2ec26f481b0a74254",
+        "size_in_bytes": 5052
+      },
+      {
+        "_path": "Lib/turtledemo/tree.py",
+        "path_type": "hardlink",
+        "sha256": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590",
+        "sha256_in_prefix": "3318448046c83c176f95a97c33b5cd82e0076bee038d72810bef3dac1085e590",
+        "size_in_bytes": 1401
+      },
+      {
+        "_path": "Lib/turtledemo/turtle.cfg",
+        "path_type": "hardlink",
+        "sha256": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88",
+        "sha256_in_prefix": "de66698dc4f083792df6aaed1e5d94e879852d72f1f24ac09c8fb4cd144c6c88",
+        "size_in_bytes": 160
+      },
+      {
+        "_path": "Lib/turtledemo/two_canvases.py",
+        "path_type": "hardlink",
+        "sha256": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96",
+        "sha256_in_prefix": "3300593114fb9286af9360cc9d871a40e5dcbea4aedc24b832607d1dd71c7b96",
+        "size_in_bytes": 1119
+      },
+      {
+        "_path": "Lib/turtledemo/yinyang.py",
+        "path_type": "hardlink",
+        "sha256": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5",
+        "sha256_in_prefix": "0737a80b939aafcf3d8a1bf60b63e781979c749337d02b6c216680893f9fffc5",
+        "size_in_bytes": 821
+      },
+      {
+        "_path": "Lib/types.py",
+        "path_type": "hardlink",
+        "sha256": "98c583498b0ff5c2b0b3949d4ed7fe567c58a3f54a0aa82ef03bd7b5862dab9e",
+        "sha256_in_prefix": "98c583498b0ff5c2b0b3949d4ed7fe567c58a3f54a0aa82ef03bd7b5862dab9e",
+        "size_in_bytes": 9785
+      },
+      {
+        "_path": "Lib/typing.py",
+        "path_type": "hardlink",
+        "sha256": "c50dd34c21da7cceaebbf87df169a9b714f3c749c3505dc99dce5b53408f34bf",
+        "sha256_in_prefix": "c50dd34c21da7cceaebbf87df169a9b714f3c749c3505dc99dce5b53408f34bf",
+        "size_in_bytes": 77044
+      },
+      {
+        "_path": "Lib/unittest/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "07bdf1fff20e4121ba61cfb64ea3c404d54ac56b053475a3a105907f48685210",
+        "sha256_in_prefix": "07bdf1fff20e4121ba61cfb64ea3c404d54ac56b053475a3a105907f48685210",
+        "size_in_bytes": 3761
+      },
+      {
+        "_path": "Lib/unittest/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3",
+        "sha256_in_prefix": "ff6b9a100d32001715b40d61bc4d613623b139edb1fdc3566427b83c331caae3",
+        "size_in_bytes": 472
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9e12d6c1efc369d12206b994846e5d94ecbdf005d9fc091f41c5d602ea7c3b48",
+        "sha256_in_prefix": "9e12d6c1efc369d12206b994846e5d94ecbdf005d9fc091f41c5d602ea7c3b48",
+        "size_in_bytes": 3381
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a8fef3d4b04cdc0ae7a389876b996aea9105fd00c77f34891a75f43d307ed3e8",
+        "sha256_in_prefix": "a8fef3d4b04cdc0ae7a389876b996aea9105fd00c77f34891a75f43d307ed3e8",
+        "size_in_bytes": 384
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/_log.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d4d08cb81089a0df8193276b6d6f624eb209e18919dfca98e6c028b86b3a7f1",
+        "sha256_in_prefix": "2d4d08cb81089a0df8193276b6d6f624eb209e18919dfca98e6c028b86b3a7f1",
+        "size_in_bytes": 2506
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/async_case.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "260e5a3948c70ca357e23c81367c0e93b6a3f9a7014af29a595ee753adadc562",
+        "sha256_in_prefix": "260e5a3948c70ca357e23c81367c0e93b6a3f9a7014af29a595ee753adadc562",
+        "size_in_bytes": 4754
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/case.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aafbd947318b97f092ecf9374e1651c891fdab6c601b92d58fcad7fb004a6831",
+        "sha256_in_prefix": "aafbd947318b97f092ecf9374e1651c891fdab6c601b92d58fcad7fb004a6831",
+        "size_in_bytes": 48150
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/loader.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "06b99d9e6c1ea52172ade1fb17e1c853051856612b1a6f4514ab1f48e318d63f",
+        "sha256_in_prefix": "06b99d9e6c1ea52172ade1fb17e1c853051856612b1a6f4514ab1f48e318d63f",
+        "size_in_bytes": 14501
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/main.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a105d7bf064dc3ff233b4e077ed1ab591d15d180743ca376c6cd6f86925e8197",
+        "sha256_in_prefix": "a105d7bf064dc3ff233b4e077ed1ab591d15d180743ca376c6cd6f86925e8197",
+        "size_in_bytes": 7513
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/mock.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5e1a30b381b36588728991de86073b4e9d49365505c112b4940c656ec6cddf82",
+        "sha256_in_prefix": "5e1a30b381b36588728991de86073b4e9d49365505c112b4940c656ec6cddf82",
+        "size_in_bytes": 78002
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/result.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2f6deec8ae54cdc90b95030476edc9a865643b48411aa7d64f7bba798bd0dcef",
+        "sha256_in_prefix": "2f6deec8ae54cdc90b95030476edc9a865643b48411aa7d64f7bba798bd0dcef",
+        "size_in_bytes": 7942
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/runner.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1a618c9ea1b6c08846a830668d6fad8cbb49c80fb5138d6d988d5ef56427223a",
+        "sha256_in_prefix": "1a618c9ea1b6c08846a830668d6fad8cbb49c80fb5138d6d988d5ef56427223a",
+        "size_in_bytes": 7172
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/signals.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5a1fd458b8b0d39f981d1eb10acaa54deec7a672bac86cbe79ee922c6241100f",
+        "sha256_in_prefix": "5a1fd458b8b0d39f981d1eb10acaa54deec7a672bac86cbe79ee922c6241100f",
+        "size_in_bytes": 2225
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/suite.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "58a52b554e399cefc5769fe4366ef628c017924e880eaec4f6947651b9242b71",
+        "sha256_in_prefix": "58a52b554e399cefc5769fe4366ef628c017924e880eaec4f6947651b9242b71",
+        "size_in_bytes": 10087
+      },
+      {
+        "_path": "Lib/unittest/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7d741428d8f49ba2fcce3649296125ec141c893fe9cb9d7e81f6c44b1b07b3cb",
+        "sha256_in_prefix": "7d741428d8f49ba2fcce3649296125ec141c893fe9cb9d7e81f6c44b1b07b3cb",
+        "size_in_bytes": 4421
+      },
+      {
+        "_path": "Lib/unittest/_log.py",
+        "path_type": "hardlink",
+        "sha256": "355a0b69b4d5b17eb029dea4bfcbd5ded3d67ccc4c9b615fc5e96a2178f08f77",
+        "sha256_in_prefix": "355a0b69b4d5b17eb029dea4bfcbd5ded3d67ccc4c9b615fc5e96a2178f08f77",
+        "size_in_bytes": 2295
+      },
+      {
+        "_path": "Lib/unittest/async_case.py",
+        "path_type": "hardlink",
+        "sha256": "2507108536605136aeba050554dc3c6c269b18d3aa9aa22e120af19681b56031",
+        "sha256_in_prefix": "2507108536605136aeba050554dc3c6c269b18d3aa9aa22e120af19681b56031",
+        "size_in_bytes": 6368
+      },
+      {
+        "_path": "Lib/unittest/case.py",
+        "path_type": "hardlink",
+        "sha256": "8056e6351eb3f987b70ac23cac7bbe9ed8b5cc3a0ba85b25c6cca32449325590",
+        "sha256_in_prefix": "8056e6351eb3f987b70ac23cac7bbe9ed8b5cc3a0ba85b25c6cca32449325590",
+        "size_in_bytes": 57155
+      },
+      {
+        "_path": "Lib/unittest/loader.py",
+        "path_type": "hardlink",
+        "sha256": "4b8d7dbfe68bc38f50e6b3952fda338e1cf9de43f299ab910cfef31c219e0342",
+        "sha256_in_prefix": "4b8d7dbfe68bc38f50e6b3952fda338e1cf9de43f299ab910cfef31c219e0342",
+        "size_in_bytes": 22702
+      },
+      {
+        "_path": "Lib/unittest/main.py",
+        "path_type": "hardlink",
+        "sha256": "360d56268ce4d561681faccf0206dc2164830de7a6dcd135f655ae5fdbdc59cf",
+        "sha256_in_prefix": "360d56268ce4d561681faccf0206dc2164830de7a6dcd135f655ae5fdbdc59cf",
+        "size_in_bytes": 11256
+      },
+      {
+        "_path": "Lib/unittest/mock.py",
+        "path_type": "hardlink",
+        "sha256": "ca4f01748eaafeb37e6b8d8933120407aa2176204b6cc074ee8dd15d2d74cf50",
+        "sha256_in_prefix": "ca4f01748eaafeb37e6b8d8933120407aa2176204b6cc074ee8dd15d2d74cf50",
+        "size_in_bytes": 99217
+      },
+      {
+        "_path": "Lib/unittest/result.py",
+        "path_type": "hardlink",
+        "sha256": "12db99e325d9f18f64fda5d8da751d72a8ed1b87ae94620e3b606f4be2dc8342",
+        "sha256_in_prefix": "12db99e325d9f18f64fda5d8da751d72a8ed1b87ae94620e3b606f4be2dc8342",
+        "size_in_bytes": 8364
+      },
+      {
+        "_path": "Lib/unittest/runner.py",
+        "path_type": "hardlink",
+        "sha256": "7ab57b963cd64f210d5a074b15e8dae9b4d1699da980dd523362d3f88e966847",
+        "sha256_in_prefix": "7ab57b963cd64f210d5a074b15e8dae9b4d1699da980dd523362d3f88e966847",
+        "size_in_bytes": 8051
+      },
+      {
+        "_path": "Lib/unittest/signals.py",
+        "path_type": "hardlink",
+        "sha256": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a",
+        "sha256_in_prefix": "f8286e818ca56e10e03745bc056cdfd31147678f9a1dc8cb6b0fe96ef9a4362a",
+        "size_in_bytes": 2403
+      },
+      {
+        "_path": "Lib/unittest/suite.py",
+        "path_type": "hardlink",
+        "sha256": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc",
+        "sha256_in_prefix": "ed2da92bc9f97c53403ee2d3d12cc53b16a96e85d596ebc887b5a93458f3f6bc",
+        "size_in_bytes": 13512
+      },
+      {
+        "_path": "Lib/unittest/test/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "8faf019fd14a59319ff1e292f00e016a0e4867b26726b00cf659ef5debd83399",
+        "sha256_in_prefix": "8faf019fd14a59319ff1e292f00e016a0e4867b26726b00cf659ef5debd83399",
+        "size_in_bytes": 584
+      },
+      {
+        "_path": "Lib/unittest/test/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "3add05dcd7dee4190919abe0323334ac96ccf05ea7d8762d68a6ce75f9d3aea5",
+        "sha256_in_prefix": "3add05dcd7dee4190919abe0323334ac96ccf05ea7d8762d68a6ce75f9d3aea5",
+        "size_in_bytes": 596
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1163972411163a798a698ee8d116edfae115ac540d791bea98d9f9c871bc9605",
+        "sha256_in_prefix": "1163972411163a798a698ee8d116edfae115ac540d791bea98d9f9c871bc9605",
+        "size_in_bytes": 753
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "43599e6580eb1b1dd78a0ac505c6988ae1cf56955a70e02ef7e7c3d9aca2d031",
+        "sha256_in_prefix": "43599e6580eb1b1dd78a0ac505c6988ae1cf56955a70e02ef7e7c3d9aca2d031",
+        "size_in_bytes": 536
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/_test_warnings.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5bf07ef67afa6b289681272d8efb8ed0fa97099e5dac6922a4af68b155f281a6",
+        "sha256_in_prefix": "5bf07ef67afa6b289681272d8efb8ed0fa97099e5dac6922a4af68b155f281a6",
+        "size_in_bytes": 2493
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/dummy.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "94c714238212061075ac442c1976070a14ac2208a44ae906a52d36b0443ba56b",
+        "sha256_in_prefix": "94c714238212061075ac442c1976070a14ac2208a44ae906a52d36b0443ba56b",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/support.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0707ba3b3eacc431d59744b64d5af260db6c6aa3d3d9cb567782f514acec10f9",
+        "sha256_in_prefix": "0707ba3b3eacc431d59744b64d5af260db6c6aa3d3d9cb567782f514acec10f9",
+        "size_in_bytes": 5976
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_assertions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "284003df91c46f2ef8be043a861d51762810f4b00471e7702c8380a4198994e6",
+        "sha256_in_prefix": "284003df91c46f2ef8be043a861d51762810f4b00471e7702c8380a4198994e6",
+        "size_in_bytes": 16526
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_async_case.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e0c460ed059840ff1b3350ae9a14179fad51343b4bbd0d278a8bf98f547c63ea",
+        "sha256_in_prefix": "e0c460ed059840ff1b3350ae9a14179fad51343b4bbd0d278a8bf98f547c63ea",
+        "size_in_bytes": 12091
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_break.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1a79a31448b53bb1d8d945a65cf5c36e036553da1a7950b693ec550e2bf0a8f1",
+        "sha256_in_prefix": "1a79a31448b53bb1d8d945a65cf5c36e036553da1a7950b693ec550e2bf0a8f1",
+        "size_in_bytes": 8293
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_case.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d1d25d1431c4e74988bfc3f79b0a45c7f6f657d39c93d5c47732b4ca41403d46",
+        "sha256_in_prefix": "d1d25d1431c4e74988bfc3f79b0a45c7f6f657d39c93d5c47732b4ca41403d46",
+        "size_in_bytes": 70738
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_discovery.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "720132164c0e2a0f1a749d4214bc8e555f0b37aca37d6d25ed57ad9756c14978",
+        "sha256_in_prefix": "720132164c0e2a0f1a749d4214bc8e555f0b37aca37d6d25ed57ad9756c14978",
+        "size_in_bytes": 33448
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_functiontestcase.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c4caf523df6f7b1d2fef1e2f60bcd5461cef25b549536bfb0d5315b1b39b094b",
+        "sha256_in_prefix": "c4caf523df6f7b1d2fef1e2f60bcd5461cef25b549536bfb0d5315b1b39b094b",
+        "size_in_bytes": 5464
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_loader.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "909d11261e1838593c393d70824a15235e2c920593a2bfa8b5eeced32ca0b629",
+        "sha256_in_prefix": "909d11261e1838593c393d70824a15235e2c920593a2bfa8b5eeced32ca0b629",
+        "size_in_bytes": 61929
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_program.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9071b607343dc9cf28bba40fca249e431215a93fdaf10b85b606cefcaf5dda2f",
+        "sha256_in_prefix": "9071b607343dc9cf28bba40fca249e431215a93fdaf10b85b606cefcaf5dda2f",
+        "size_in_bytes": 16393
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_result.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4fa74e6b51d65b4d5bf3175cc37c994a0fbcccff9d602f43977f7377ef05c609",
+        "sha256_in_prefix": "4fa74e6b51d65b4d5bf3175cc37c994a0fbcccff9d602f43977f7377ef05c609",
+        "size_in_bytes": 43422
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_runner.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9274306e3b1b984ccd0a46b7d5c39fc8906d019c032bef05eb045df91cd5942c",
+        "sha256_in_prefix": "9274306e3b1b984ccd0a46b7d5c39fc8906d019c032bef05eb045df91cd5942c",
+        "size_in_bytes": 57710
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_setups.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5626adc84d1e5ff7bfc94e7271e28bcacfb019eeb04253caee630b8b2235a71c",
+        "sha256_in_prefix": "5626adc84d1e5ff7bfc94e7271e28bcacfb019eeb04253caee630b8b2235a71c",
+        "size_in_bytes": 28299
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_skipping.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e83acbfe6ba3c0417f48f40ef96923fb39c4a25411075c90c337395b7348aab0",
+        "sha256_in_prefix": "e83acbfe6ba3c0417f48f40ef96923fb39c4a25411075c90c337395b7348aab0",
+        "size_in_bytes": 25459
+      },
+      {
+        "_path": "Lib/unittest/test/__pycache__/test_suite.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4b5a3ad09744ef08cc2a47c27a90c165356b158f68b1c3aa80e231dd0ee8e526",
+        "sha256_in_prefix": "4b5a3ad09744ef08cc2a47c27a90c165356b158f68b1c3aa80e231dd0ee8e526",
+        "size_in_bytes": 16282
+      },
+      {
+        "_path": "Lib/unittest/test/_test_warnings.py",
+        "path_type": "hardlink",
+        "sha256": "19cad5a18db63d2cf37ccbc75166d186166c32f44f89d898bf47ba5016e6de91",
+        "sha256_in_prefix": "19cad5a18db63d2cf37ccbc75166d186166c32f44f89d898bf47ba5016e6de91",
+        "size_in_bytes": 2304
+      },
+      {
+        "_path": "Lib/unittest/test/dummy.py",
+        "path_type": "hardlink",
+        "sha256": "5ec85038c527bd87cc6a9f8842324329097cf599462e886536d13211343c7717",
+        "sha256_in_prefix": "5ec85038c527bd87cc6a9f8842324329097cf599462e886536d13211343c7717",
+        "size_in_bytes": 50
+      },
+      {
+        "_path": "Lib/unittest/test/support.py",
+        "path_type": "hardlink",
+        "sha256": "666649ba205681dc9a3e0650a4ab7b8752ca3788115b7e9ba76df89456e827d6",
+        "sha256_in_prefix": "666649ba205681dc9a3e0650a4ab7b8752ca3788115b7e9ba76df89456e827d6",
+        "size_in_bytes": 3752
+      },
+      {
+        "_path": "Lib/unittest/test/test_assertions.py",
+        "path_type": "hardlink",
+        "sha256": "a64613077bd6869c8bb9d72adcd91e21adbb928a3f4c465742a44fa626657775",
+        "sha256_in_prefix": "a64613077bd6869c8bb9d72adcd91e21adbb928a3f4c465742a44fa626657775",
+        "size_in_bytes": 17208
+      },
+      {
+        "_path": "Lib/unittest/test/test_async_case.py",
+        "path_type": "hardlink",
+        "sha256": "b39bafe8593c3edfff894c8b2ec1da5fcc8db11e2e4af39d2664c3140c446603",
+        "sha256_in_prefix": "b39bafe8593c3edfff894c8b2ec1da5fcc8db11e2e4af39d2664c3140c446603",
+        "size_in_bytes": 10215
+      },
+      {
+        "_path": "Lib/unittest/test/test_break.py",
+        "path_type": "hardlink",
+        "sha256": "89c7b021569ffdb865944c6dab803751808ef827ad4e9a51b727148faf99cd4a",
+        "sha256_in_prefix": "89c7b021569ffdb865944c6dab803751808ef827ad4e9a51b727148faf99cd4a",
+        "size_in_bytes": 9493
+      },
+      {
+        "_path": "Lib/unittest/test/test_case.py",
+        "path_type": "hardlink",
+        "sha256": "e6830c99b005e278f0cc06df5dcb2e153278f8a97634411f09627424f569bfc2",
+        "sha256_in_prefix": "e6830c99b005e278f0cc06df5dcb2e153278f8a97634411f09627424f569bfc2",
+        "size_in_bytes": 73763
+      },
+      {
+        "_path": "Lib/unittest/test/test_discovery.py",
+        "path_type": "hardlink",
+        "sha256": "be2329afabb2ba713e7b2deae1a1a3b0645a4322bc05a2e9496563da8a7763b2",
+        "sha256_in_prefix": "be2329afabb2ba713e7b2deae1a1a3b0645a4322bc05a2e9496563da8a7763b2",
+        "size_in_bytes": 34008
+      },
+      {
+        "_path": "Lib/unittest/test/test_functiontestcase.py",
+        "path_type": "hardlink",
+        "sha256": "7aa51c1ee046da0cdec8f9ac06d72a7741a1dd4a12491e3a3c8eb2c87094f169",
+        "sha256_in_prefix": "7aa51c1ee046da0cdec8f9ac06d72a7741a1dd4a12491e3a3c8eb2c87094f169",
+        "size_in_bytes": 5540
+      },
+      {
+        "_path": "Lib/unittest/test/test_loader.py",
+        "path_type": "hardlink",
+        "sha256": "5157907c78f7584cbd8ded6a2518ef3ae01c0470af8306c9c93f2b16b277290e",
+        "sha256_in_prefix": "5157907c78f7584cbd8ded6a2518ef3ae01c0470af8306c9c93f2b16b277290e",
+        "size_in_bytes": 63055
+      },
+      {
+        "_path": "Lib/unittest/test/test_program.py",
+        "path_type": "hardlink",
+        "sha256": "00e04e61db9e6b254ca53394e308751332fa1822d16a2074cbf51d96fd41e0a4",
+        "sha256_in_prefix": "00e04e61db9e6b254ca53394e308751332fa1822d16a2074cbf51d96fd41e0a4",
+        "size_in_bytes": 15530
+      },
+      {
+        "_path": "Lib/unittest/test/test_result.py",
+        "path_type": "hardlink",
+        "sha256": "6ab75d4fda8f38feffce4cd5d0e122f907aac22cb7676293a5f687c6b1bd92be",
+        "sha256_in_prefix": "6ab75d4fda8f38feffce4cd5d0e122f907aac22cb7676293a5f687c6b1bd92be",
+        "size_in_bytes": 45634
+      },
+      {
+        "_path": "Lib/unittest/test/test_runner.py",
+        "path_type": "hardlink",
+        "sha256": "ebc8ce658ee81b4ce7f62fc44193fd1bc4e762f3784cb3568323a5e4ab39b935",
+        "sha256_in_prefix": "ebc8ce658ee81b4ce7f62fc44193fd1bc4e762f3784cb3568323a5e4ab39b935",
+        "size_in_bytes": 44482
+      },
+      {
+        "_path": "Lib/unittest/test/test_setups.py",
+        "path_type": "hardlink",
+        "sha256": "0bd10fabe5314c160aea7aff21f59a9f5cd272d97327fbf391e096df3dcfc6f4",
+        "sha256_in_prefix": "0bd10fabe5314c160aea7aff21f59a9f5cd272d97327fbf391e096df3dcfc6f4",
+        "size_in_bytes": 16503
+      },
+      {
+        "_path": "Lib/unittest/test/test_skipping.py",
+        "path_type": "hardlink",
+        "sha256": "21985730bd2ffb40038363e5e23f0b2bfb774beece233e2d94a71a1b6b93a4da",
+        "sha256_in_prefix": "21985730bd2ffb40038363e5e23f0b2bfb774beece233e2d94a71a1b6b93a4da",
+        "size_in_bytes": 20080
+      },
+      {
+        "_path": "Lib/unittest/test/test_suite.py",
+        "path_type": "hardlink",
+        "sha256": "a8a8e4b6a10d6287210bc33113bfb2b739c6cfaea99717690945045e683b3b9b",
+        "sha256_in_prefix": "a8a8e4b6a10d6287210bc33113bfb2b739c6cfaea99717690945045e683b3b9b",
+        "size_in_bytes": 15184
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "d09e5eceb09b486c3f8bda429cc1b1927ef65e568d583b37de53f4f9812771f3",
+        "sha256_in_prefix": "d09e5eceb09b486c3f8bda429cc1b1927ef65e568d583b37de53f4f9812771f3",
+        "size_in_bytes": 465
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "bbbc16cb8b42e626b7562a7a9c8febd810c759f844bbedab2d3425b674da47a0",
+        "sha256_in_prefix": "bbbc16cb8b42e626b7562a7a9c8febd810c759f844bbedab2d3425b674da47a0",
+        "size_in_bytes": 623
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de44d6677ff34e520495f3dd1f30a0efefec2ec72db317b3537493b68afed355",
+        "sha256_in_prefix": "de44d6677ff34e520495f3dd1f30a0efefec2ec72db317b3537493b68afed355",
+        "size_in_bytes": 658
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e4379c148d158235b91d9f7035b43e3537f5e510009ea7d2081eae2c53c6c393",
+        "sha256_in_prefix": "e4379c148d158235b91d9f7035b43e3537f5e510009ea7d2081eae2c53c6c393",
+        "size_in_bytes": 552
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/support.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3fd9c5c25b9f15c3c38b542978aae43b72ed2e0237c16e927251871f616c6105",
+        "sha256_in_prefix": "3fd9c5c25b9f15c3c38b542978aae43b72ed2e0237c16e927251871f616c6105",
+        "size_in_bytes": 775
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/testasync.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cfd25ba349ccf6bf9a983268e143caa3bef5e41b125340af7f8e4276cd32c670",
+        "sha256_in_prefix": "cfd25ba349ccf6bf9a983268e143caa3bef5e41b125340af7f8e4276cd32c670",
+        "size_in_bytes": 46317
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/testcallable.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "06bde684d987376dee032ad4f49fb7a6b2bd67430bd2d90ef6468839fb94eaa1",
+        "sha256_in_prefix": "06bde684d987376dee032ad4f49fb7a6b2bd67430bd2d90ef6468839fb94eaa1",
+        "size_in_bytes": 5074
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/testhelpers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ab9dbdb5944b54b054f9d437111f091946fc64bedde134b5297b25d8a0106b31",
+        "sha256_in_prefix": "ab9dbdb5944b54b054f9d437111f091946fc64bedde134b5297b25d8a0106b31",
+        "size_in_bytes": 42863
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/testmagicmethods.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e638b1bd74b949bff2c8fe102c580469acde4493b95e8d649e92dc3ea1eff9f5",
+        "sha256_in_prefix": "e638b1bd74b949bff2c8fe102c580469acde4493b95e8d649e92dc3ea1eff9f5",
+        "size_in_bytes": 20704
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/testmock.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a9da8a3bb09cb2bdb77c3ad0af7f156f1b207ef042886414394f14d50ba5d180",
+        "sha256_in_prefix": "a9da8a3bb09cb2bdb77c3ad0af7f156f1b207ef042886414394f14d50ba5d180",
+        "size_in_bytes": 70254
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/testpatch.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b28b12014f4565365eaf4a6745e59ba18bde954634db9857190fb52ad2f34600",
+        "sha256_in_prefix": "b28b12014f4565365eaf4a6745e59ba18bde954634db9857190fb52ad2f34600",
+        "size_in_bytes": 70317
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/testsealable.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bbed0de9a59c15509a1519051dc612a2e00dee9b942b25f80ad75177a2ad4ffa",
+        "sha256_in_prefix": "bbed0de9a59c15509a1519051dc612a2e00dee9b942b25f80ad75177a2ad4ffa",
+        "size_in_bytes": 9186
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/testsentinel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ecff386dded9046407c68920ffd48f98c0a3548040097a87bf32db55c9aea47a",
+        "sha256_in_prefix": "ecff386dded9046407c68920ffd48f98c0a3548040097a87bf32db55c9aea47a",
+        "size_in_bytes": 1974
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/__pycache__/testwith.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f0f0b5cf260a9fbf4e8d8825844ead66d14e2de4596bd4301e703f552360e812",
+        "sha256_in_prefix": "f0f0b5cf260a9fbf4e8d8825844ead66d14e2de4596bd4301e703f552360e812",
+        "size_in_bytes": 12303
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/support.py",
+        "path_type": "hardlink",
+        "sha256": "cb226f9cd99f7a80db68391bc9e4cbfdc8b7488c4ce2fdf345235fd0d0ffb3bd",
+        "sha256_in_prefix": "cb226f9cd99f7a80db68391bc9e4cbfdc8b7488c4ce2fdf345235fd0d0ffb3bd",
+        "size_in_bytes": 268
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/testasync.py",
+        "path_type": "hardlink",
+        "sha256": "720ed785efa820871fb88f95c78c2e23e6570dadd1fbbf179af9ecd2e2d0232e",
+        "sha256_in_prefix": "720ed785efa820871fb88f95c78c2e23e6570dadd1fbbf179af9ecd2e2d0232e",
+        "size_in_bytes": 37206
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/testcallable.py",
+        "path_type": "hardlink",
+        "sha256": "282f1825ab17973059621d92863eb385a7246d3583bdef5f82e142cff58d7f65",
+        "sha256_in_prefix": "282f1825ab17973059621d92863eb385a7246d3583bdef5f82e142cff58d7f65",
+        "size_in_bytes": 4267
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/testhelpers.py",
+        "path_type": "hardlink",
+        "sha256": "a8831a626d02e171d8f81c0ecb15bcc6bbc8fb7db99d2eb53b56e0f9843e24b1",
+        "sha256_in_prefix": "a8831a626d02e171d8f81c0ecb15bcc6bbc8fb7db99d2eb53b56e0f9843e24b1",
+        "size_in_bytes": 33648
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/testmagicmethods.py",
+        "path_type": "hardlink",
+        "sha256": "2d7dd1368e34002c3050d92b380ebeba2751157500b2fb92c3288e5cc098108b",
+        "sha256_in_prefix": "2d7dd1368e34002c3050d92b380ebeba2751157500b2fb92c3288e5cc098108b",
+        "size_in_bytes": 16243
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/testmock.py",
+        "path_type": "hardlink",
+        "sha256": "bd3cce633e135598602525d1dc137fd129c1e3df182506a4ea90de5aff877d2a",
+        "sha256_in_prefix": "bd3cce633e135598602525d1dc137fd129c1e3df182506a4ea90de5aff877d2a",
+        "size_in_bytes": 71837
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/testpatch.py",
+        "path_type": "hardlink",
+        "sha256": "b94bdbbff4c10843000d6f8e697221e5362b598afab0680397bbe88a6d3adfbe",
+        "sha256_in_prefix": "b94bdbbff4c10843000d6f8e697221e5362b598afab0680397bbe88a6d3adfbe",
+        "size_in_bytes": 59141
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/testsealable.py",
+        "path_type": "hardlink",
+        "sha256": "154919b15d47165081f349415090ea49d9b9509c4c9432ccb183201f0b67c931",
+        "sha256_in_prefix": "154919b15d47165081f349415090ea49d9b9509c4c9432ccb183201f0b67c931",
+        "size_in_bytes": 7369
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/testsentinel.py",
+        "path_type": "hardlink",
+        "sha256": "34f10ee69edee4a879ff88e15b00b09466e1df3a1bb6080673c215e17e305bb1",
+        "sha256_in_prefix": "34f10ee69edee4a879ff88e15b00b09466e1df3a1bb6080673c215e17e305bb1",
+        "size_in_bytes": 1325
+      },
+      {
+        "_path": "Lib/unittest/test/testmock/testwith.py",
+        "path_type": "hardlink",
+        "sha256": "27e4d7b2a2e9f816ed19edc6278c9c633265c727acc041e6624421411dc29bb1",
+        "sha256_in_prefix": "27e4d7b2a2e9f816ed19edc6278c9c633265c727acc041e6624421411dc29bb1",
+        "size_in_bytes": 12259
+      },
+      {
+        "_path": "Lib/unittest/util.py",
+        "path_type": "hardlink",
+        "sha256": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d",
+        "sha256_in_prefix": "fdcc640c3505d16deab9c32eae7c3f5f67c3b5e81c563dc6698fa7fcf403854d",
+        "size_in_bytes": 5215
+      },
+      {
+        "_path": "Lib/urllib/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/urllib/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2dcd3a0cf65dba5014e9980116580454dd39e76e8e0bdad381eb5047255f8f7a",
+        "sha256_in_prefix": "2dcd3a0cf65dba5014e9980116580454dd39e76e8e0bdad381eb5047255f8f7a",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "Lib/urllib/__pycache__/error.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9eaac190503a7511f730a6e63c3e88ad2ce281a311824141f1ad3eb3a58b3995",
+        "sha256_in_prefix": "9eaac190503a7511f730a6e63c3e88ad2ce281a311824141f1ad3eb3a58b3995",
+        "size_in_bytes": 2809
+      },
+      {
+        "_path": "Lib/urllib/__pycache__/parse.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0eec2d083ea7205ef7d6f269d1e770cca2717b6df6eede3060ef6f979b6651ec",
+        "sha256_in_prefix": "0eec2d083ea7205ef7d6f269d1e770cca2717b6df6eede3060ef6f979b6651ec",
+        "size_in_bytes": 35643
+      },
+      {
+        "_path": "Lib/urllib/__pycache__/request.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8238bd20cf03689ea7cfa703456cf52e3777dc6398107d6811649b3be7436499",
+        "sha256_in_prefix": "8238bd20cf03689ea7cfa703456cf52e3777dc6398107d6811649b3be7436499",
+        "size_in_bytes": 72560
+      },
+      {
+        "_path": "Lib/urllib/__pycache__/response.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d1b1be4611de547d8415c66f6842e8c8028d7877e6f0aa69cbeb65d0e5976088",
+        "sha256_in_prefix": "d1b1be4611de547d8415c66f6842e8c8028d7877e6f0aa69cbeb65d0e5976088",
+        "size_in_bytes": 3439
+      },
+      {
+        "_path": "Lib/urllib/__pycache__/robotparser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "13b5577911658a809995070423f387bc6a20bbcff9a332a66c424379fa617b73",
+        "sha256_in_prefix": "13b5577911658a809995070423f387bc6a20bbcff9a332a66c424379fa617b73",
+        "size_in_bytes": 7310
+      },
+      {
+        "_path": "Lib/urllib/error.py",
+        "path_type": "hardlink",
+        "sha256": "4483fa9480d119848ab8d4feb649b94d48dd899820d4c4959fbe30f2511cda90",
+        "sha256_in_prefix": "4483fa9480d119848ab8d4feb649b94d48dd899820d4c4959fbe30f2511cda90",
+        "size_in_bytes": 2632
+      },
+      {
+        "_path": "Lib/urllib/parse.py",
+        "path_type": "hardlink",
+        "sha256": "c1c850aff0a577ab3b40c413f435c7eb0bb7d98a9f4062cff8dbd22b79b4a5ea",
+        "sha256_in_prefix": "c1c850aff0a577ab3b40c413f435c7eb0bb7d98a9f4062cff8dbd22b79b4a5ea",
+        "size_in_bytes": 43777
+      },
+      {
+        "_path": "Lib/urllib/request.py",
+        "path_type": "hardlink",
+        "sha256": "e7ba9ce5309f13b5ed53dceb2802b15b3f4ae02b0567c3fbc5b3b7e8c4f4dc87",
+        "sha256_in_prefix": "e7ba9ce5309f13b5ed53dceb2802b15b3f4ae02b0567c3fbc5b3b7e8c4f4dc87",
+        "size_in_bytes": 101306
+      },
+      {
+        "_path": "Lib/urllib/response.py",
+        "path_type": "hardlink",
+        "sha256": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76",
+        "sha256_in_prefix": "7e6c3b6d7a95f0d74f5968f51a87adae8a51bf42390cdfec98c7a99203e7bb76",
+        "size_in_bytes": 2361
+      },
+      {
+        "_path": "Lib/urllib/robotparser.py",
+        "path_type": "hardlink",
+        "sha256": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc",
+        "sha256_in_prefix": "389b811835f9a3ba72b192c3487b0266fa31f6e571b7a83ceb2a34792dc0d9fc",
+        "size_in_bytes": 9424
+      },
+      {
+        "_path": "Lib/uu.py",
+        "path_type": "hardlink",
+        "sha256": "11c44d6915c8c76cbd33e1989d90f3846c041abea1148f230d3ff7144fb69837",
+        "sha256_in_prefix": "11c44d6915c8c76cbd33e1989d90f3846c041abea1148f230d3ff7144fb69837",
+        "size_in_bytes": 7301
+      },
+      {
+        "_path": "Lib/uuid.py",
+        "path_type": "hardlink",
+        "sha256": "90111781a858747fd8b9ace31e199debc8098c51dbe5ae894157040ed69ce70d",
+        "sha256_in_prefix": "90111781a858747fd8b9ace31e199debc8098c51dbe5ae894157040ed69ce70d",
+        "size_in_bytes": 27324
+      },
+      {
+        "_path": "Lib/venv/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "95513327c9f63a35446da05a60cc2f659b770a3d593c45e713da7c83c65e9adb",
+        "sha256_in_prefix": "95513327c9f63a35446da05a60cc2f659b770a3d593c45e713da7c83c65e9adb",
+        "size_in_bytes": 24620
+      },
+      {
+        "_path": "Lib/venv/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36",
+        "sha256_in_prefix": "722537c68c0622f8293d39bb6ab1288f3637d8dc45d6f9aae96e49af8145ca36",
+        "size_in_bytes": 145
+      },
+      {
+        "_path": "Lib/venv/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "afa661bc2d1fe9b3a7dd3e49a1490de8dc944baeefaa92fbb86f05cc76d7b311",
+        "sha256_in_prefix": "afa661bc2d1fe9b3a7dd3e49a1490de8dc944baeefaa92fbb86f05cc76d7b311",
+        "size_in_bytes": 16784
+      },
+      {
+        "_path": "Lib/venv/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "18127ed77f55271aec710cd7da497ba92068df79815e5406b52d7248e4e3d059",
+        "sha256_in_prefix": "18127ed77f55271aec710cd7da497ba92068df79815e5406b52d7248e4e3d059",
+        "size_in_bytes": 316
+      },
+      {
+        "_path": "Lib/venv/scripts/common/Activate.ps1",
+        "path_type": "hardlink",
+        "sha256": "07c71e3f4cd0102046dd9f9a5fef4cab50326dd5ae859b078096196039977c1e",
+        "sha256_in_prefix": "07c71e3f4cd0102046dd9f9a5fef4cab50326dd5ae859b078096196039977c1e",
+        "size_in_bytes": 8834
+      },
+      {
+        "_path": "Lib/venv/scripts/common/activate",
+        "path_type": "hardlink",
+        "sha256": "b6d500647353baa198626edca5639951ae8b1695a4488559f9757efac4ad5e48",
+        "sha256_in_prefix": "b6d500647353baa198626edca5639951ae8b1695a4488559f9757efac4ad5e48",
+        "size_in_bytes": 1909
+      },
+      {
+        "_path": "Lib/venv/scripts/nt/activate.bat",
+        "path_type": "hardlink",
+        "sha256": "e94b972a9b4fd6ef58fdc4f618819247c9a9006ec8a7bd7fd3d8a775c3c18cfb",
+        "sha256_in_prefix": "e94b972a9b4fd6ef58fdc4f618819247c9a9006ec8a7bd7fd3d8a775c3c18cfb",
+        "size_in_bytes": 971
+      },
+      {
+        "_path": "Lib/venv/scripts/nt/deactivate.bat",
+        "path_type": "hardlink",
+        "sha256": "a1a72a793b74a5e522507e252940b3b332c8897ad438a5e60a042b6ef2c8fbec",
+        "sha256_in_prefix": "a1a72a793b74a5e522507e252940b3b332c8897ad438a5e60a042b6ef2c8fbec",
+        "size_in_bytes": 368
+      },
+      {
+        "_path": "Lib/venv/scripts/posix/activate.csh",
+        "path_type": "hardlink",
+        "sha256": "cb7a598734e196dce2b7bd73e4cdfe6739bb25ae2d5609820974e590ada85bfe",
+        "sha256_in_prefix": "cb7a598734e196dce2b7bd73e4cdfe6739bb25ae2d5609820974e590ada85bfe",
+        "size_in_bytes": 858
+      },
+      {
+        "_path": "Lib/venv/scripts/posix/activate.fish",
+        "path_type": "hardlink",
+        "sha256": "26d5c606512e02f3133b52c3580682c3819037b4bb0c703e939039c2a512a6bc",
+        "sha256_in_prefix": "26d5c606512e02f3133b52c3580682c3819037b4bb0c703e939039c2a512a6bc",
+        "size_in_bytes": 1994
+      },
+      {
+        "_path": "Lib/warnings.py",
+        "path_type": "hardlink",
+        "sha256": "b8e7748e4c67eb65cea5d3b3bd888d245771c0ebe63117f747189a55a9b622db",
+        "sha256_in_prefix": "b8e7748e4c67eb65cea5d3b3bd888d245771c0ebe63117f747189a55a9b622db",
+        "size_in_bytes": 19688
+      },
+      {
+        "_path": "Lib/wave.py",
+        "path_type": "hardlink",
+        "sha256": "2d6ddc0c5e408bb993274ad4f7806252158fec7c569e5a78a50a06ecf02e681d",
+        "sha256_in_prefix": "2d6ddc0c5e408bb993274ad4f7806252158fec7c569e5a78a50a06ecf02e681d",
+        "size_in_bytes": 18004
+      },
+      {
+        "_path": "Lib/weakref.py",
+        "path_type": "hardlink",
+        "sha256": "dd8e03473ee5667c1a2caa43ede07797652bcb4035fabb60d60af10bb23a0886",
+        "sha256_in_prefix": "dd8e03473ee5667c1a2caa43ede07797652bcb4035fabb60d60af10bb23a0886",
+        "size_in_bytes": 21560
+      },
+      {
+        "_path": "Lib/webbrowser.py",
+        "path_type": "hardlink",
+        "sha256": "b3ed3f0114d33a456b4e9e65a08ee744d39f6d7d59eb8286906eb302326147eb",
+        "sha256_in_prefix": "b3ed3f0114d33a456b4e9e65a08ee744d39f6d7d59eb8286906eb302326147eb",
+        "size_in_bytes": 24085
+      },
+      {
+        "_path": "Lib/wsgiref/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "db2259a74988dc73a209cdf7aaa3b79ab6f213384287a8bd288ad141a935e236",
+        "sha256_in_prefix": "db2259a74988dc73a209cdf7aaa3b79ab6f213384287a8bd288ad141a935e236",
+        "size_in_bytes": 587
+      },
+      {
+        "_path": "Lib/wsgiref/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9280896914ce30ec1739f150945e6624c1b72d03a77423fd67d4c7ab67be9d35",
+        "sha256_in_prefix": "9280896914ce30ec1739f150945e6624c1b72d03a77423fd67d4c7ab67be9d35",
+        "size_in_bytes": 709
+      },
+      {
+        "_path": "Lib/wsgiref/__pycache__/handlers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cc4aa34e841ba8728da4e8000fdbe6a2b8c715ce13ee003beac18e69030d5642",
+        "sha256_in_prefix": "cc4aa34e841ba8728da4e8000fdbe6a2b8c715ce13ee003beac18e69030d5642",
+        "size_in_bytes": 16359
+      },
+      {
+        "_path": "Lib/wsgiref/__pycache__/headers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "51ba7e0737f20f82f758732eca4b61a407f03eb95e75256191d07145ce9d9287",
+        "sha256_in_prefix": "51ba7e0737f20f82f758732eca4b61a407f03eb95e75256191d07145ce9d9287",
+        "size_in_bytes": 7717
+      },
+      {
+        "_path": "Lib/wsgiref/__pycache__/simple_server.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "41d0eb9fde078e7489257665e02dec3d773b344b6a5987dcd80ac86ef7c94913",
+        "sha256_in_prefix": "41d0eb9fde078e7489257665e02dec3d773b344b6a5987dcd80ac86ef7c94913",
+        "size_in_bytes": 5284
+      },
+      {
+        "_path": "Lib/wsgiref/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "361bd8a52846b11c148063424bab10fa7c30d8508e51531c6a903997bf67a093",
+        "sha256_in_prefix": "361bd8a52846b11c148063424bab10fa7c30d8508e51531c6a903997bf67a093",
+        "size_in_bytes": 5378
+      },
+      {
+        "_path": "Lib/wsgiref/__pycache__/validate.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dc2251e3a89409270c98fc40a9d6b8a367030a6cf698b92650315526bec942b6",
+        "sha256_in_prefix": "dc2251e3a89409270c98fc40a9d6b8a367030a6cf698b92650315526bec942b6",
+        "size_in_bytes": 14740
+      },
+      {
+        "_path": "Lib/wsgiref/handlers.py",
+        "path_type": "hardlink",
+        "sha256": "2b4afb6eb7db05f7c6d1785853cfd45f870fcf65997a7bc5419c36d1dba67191",
+        "sha256_in_prefix": "2b4afb6eb7db05f7c6d1785853cfd45f870fcf65997a7bc5419c36d1dba67191",
+        "size_in_bytes": 21669
+      },
+      {
+        "_path": "Lib/wsgiref/headers.py",
+        "path_type": "hardlink",
+        "sha256": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9",
+        "sha256_in_prefix": "0fbf95a47d8e4c0d831fd52312ec43076cbf503c190269876f170a5cf5585fb9",
+        "size_in_bytes": 6766
+      },
+      {
+        "_path": "Lib/wsgiref/simple_server.py",
+        "path_type": "hardlink",
+        "sha256": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b",
+        "sha256_in_prefix": "d435cad48b5f63c0356e1ac70755e6e35eb94b02f9844b813e5762199110bc2b",
+        "size_in_bytes": 5171
+      },
+      {
+        "_path": "Lib/wsgiref/util.py",
+        "path_type": "hardlink",
+        "sha256": "dcb02730111ea1afdfb7520b37feecce28eb56e2c98fe9fc5a3778547e73ce6e",
+        "sha256_in_prefix": "dcb02730111ea1afdfb7520b37feecce28eb56e2c98fe9fc5a3778547e73ce6e",
+        "size_in_bytes": 5851
+      },
+      {
+        "_path": "Lib/wsgiref/validate.py",
+        "path_type": "hardlink",
+        "sha256": "ac13535800c4d72b2f37e47de147bce4ffdb5e14d9372453bd14984ddbd13ca3",
+        "sha256_in_prefix": "ac13535800c4d72b2f37e47de147bce4ffdb5e14d9372453bd14984ddbd13ca3",
+        "size_in_bytes": 15099
+      },
+      {
+        "_path": "Lib/xdrlib.py",
+        "path_type": "hardlink",
+        "sha256": "5bae885a7da49c1fdca1136bf5aece233f0b8f4a6948da3969072c26de395e83",
+        "sha256_in_prefix": "5bae885a7da49c1fdca1136bf5aece233f0b8f4a6948da3969072c26de395e83",
+        "size_in_bytes": 5913
+      },
+      {
+        "_path": "Lib/xml/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811",
+        "sha256_in_prefix": "34296f728e7fe68cccb97a9f6edbf3bf3a686f44044c744fe85f207a92ed4811",
+        "size_in_bytes": 557
+      },
+      {
+        "_path": "Lib/xml/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d085607d3bcefb00ae43562d2a268a975e62547e7e18041f7a4a6430aa12918d",
+        "sha256_in_prefix": "d085607d3bcefb00ae43562d2a268a975e62547e7e18041f7a4a6430aa12918d",
+        "size_in_bytes": 675
+      },
+      {
+        "_path": "Lib/xml/dom/NodeFilter.py",
+        "path_type": "hardlink",
+        "sha256": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7",
+        "sha256_in_prefix": "9bfacbbb64e239a75591a7260b3ed86748eeb4366e6c40f3542753e79bace9a7",
+        "size_in_bytes": 936
+      },
+      {
+        "_path": "Lib/xml/dom/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a",
+        "sha256_in_prefix": "b415a6f3d3663c3ac332ee4a0f4213eadad9281508dc97410e258a03633b063a",
+        "size_in_bytes": 4019
+      },
+      {
+        "_path": "Lib/xml/dom/__pycache__/NodeFilter.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "42d620a556c34a636701a8af69a423b76bb699e61384d216c802dd726b69ac79",
+        "sha256_in_prefix": "42d620a556c34a636701a8af69a423b76bb699e61384d216c802dd726b69ac79",
+        "size_in_bytes": 952
+      },
+      {
+        "_path": "Lib/xml/dom/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d8103f4c1e818e41ce463235105105b5e335b2882e3eb06aa0eb619862c2a496",
+        "sha256_in_prefix": "d8103f4c1e818e41ce463235105105b5e335b2882e3eb06aa0eb619862c2a496",
+        "size_in_bytes": 5521
+      },
+      {
+        "_path": "Lib/xml/dom/__pycache__/domreg.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "629cb7f97f04c3b014c2730038f3cfc9f8636bcadfe82d8b1a1991454819ecf2",
+        "sha256_in_prefix": "629cb7f97f04c3b014c2730038f3cfc9f8636bcadfe82d8b1a1991454819ecf2",
+        "size_in_bytes": 2833
+      },
+      {
+        "_path": "Lib/xml/dom/__pycache__/expatbuilder.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d3a9de647591a8068ed1ef174967a74c779389395827489caf66957d0cd2afa0",
+        "sha256_in_prefix": "d3a9de647591a8068ed1ef174967a74c779389395827489caf66957d0cd2afa0",
+        "size_in_bytes": 27293
+      },
+      {
+        "_path": "Lib/xml/dom/__pycache__/minicompat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "192251eac10735923fc334dd77cadf76589d6d46a3646c274c4cbf05aac6cdb5",
+        "sha256_in_prefix": "192251eac10735923fc334dd77cadf76589d6d46a3646c274c4cbf05aac6cdb5",
+        "size_in_bytes": 2724
+      },
+      {
+        "_path": "Lib/xml/dom/__pycache__/minidom.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c2386b8919dd7d83fc20073ed5a37f82d896215b6021481747104fe386d8134b",
+        "sha256_in_prefix": "c2386b8919dd7d83fc20073ed5a37f82d896215b6021481747104fe386d8134b",
+        "size_in_bytes": 56294
+      },
+      {
+        "_path": "Lib/xml/dom/__pycache__/pulldom.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "df0f2c33b56bbec6f3d8e98e75061b5eb1bcf55d7151dbf930931f92de026e32",
+        "sha256_in_prefix": "df0f2c33b56bbec6f3d8e98e75061b5eb1bcf55d7151dbf930931f92de026e32",
+        "size_in_bytes": 10674
+      },
+      {
+        "_path": "Lib/xml/dom/__pycache__/xmlbuilder.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2ba998d0f5607d2b7b2f1fbf4595efa3d961b0a0450b2f8f2967e80061c9c44c",
+        "sha256_in_prefix": "2ba998d0f5607d2b7b2f1fbf4595efa3d961b0a0450b2f8f2967e80061c9c44c",
+        "size_in_bytes": 12460
+      },
+      {
+        "_path": "Lib/xml/dom/domreg.py",
+        "path_type": "hardlink",
+        "sha256": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8",
+        "sha256_in_prefix": "826b02a803930834b96b1086cbee7db1d21c684f65dd3073706dc7bb5ba1a3e8",
+        "size_in_bytes": 3451
+      },
+      {
+        "_path": "Lib/xml/dom/expatbuilder.py",
+        "path_type": "hardlink",
+        "sha256": "40ebc018d1f1d7f16121f2dec0cede039fea8a89bf18862d7ed3489adb934be8",
+        "sha256_in_prefix": "40ebc018d1f1d7f16121f2dec0cede039fea8a89bf18862d7ed3489adb934be8",
+        "size_in_bytes": 35767
+      },
+      {
+        "_path": "Lib/xml/dom/minicompat.py",
+        "path_type": "hardlink",
+        "sha256": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be",
+        "sha256_in_prefix": "42974c4c67803dfe80b016ff8aeea0d1e5c751703ab3aec5be765f4e534367be",
+        "size_in_bytes": 3367
+      },
+      {
+        "_path": "Lib/xml/dom/minidom.py",
+        "path_type": "hardlink",
+        "sha256": "9684ca07a67464ee178086d10c76d2e1c5c19ca5d2343357fe94bb58e1dff2fa",
+        "sha256_in_prefix": "9684ca07a67464ee178086d10c76d2e1c5c19ca5d2343357fe94bb58e1dff2fa",
+        "size_in_bytes": 68066
+      },
+      {
+        "_path": "Lib/xml/dom/pulldom.py",
+        "path_type": "hardlink",
+        "sha256": "99dd807c260c3bfa754c0515d390f6041c8f040355f4c628fd4f89a5641bee21",
+        "sha256_in_prefix": "99dd807c260c3bfa754c0515d390f6041c8f040355f4c628fd4f89a5641bee21",
+        "size_in_bytes": 11997
+      },
+      {
+        "_path": "Lib/xml/dom/xmlbuilder.py",
+        "path_type": "hardlink",
+        "sha256": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf",
+        "sha256_in_prefix": "d4f33a8f018755626b64557953a91c6bba21ff613da46f7558a2874aa5d08ebf",
+        "size_in_bytes": 12387
+      },
+      {
+        "_path": "Lib/xml/etree/ElementInclude.py",
+        "path_type": "hardlink",
+        "sha256": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0",
+        "sha256_in_prefix": "97b513db52e9d8382d446e283583e3adf20aae86fb93d4764565ac08250399c0",
+        "size_in_bytes": 6882
+      },
+      {
+        "_path": "Lib/xml/etree/ElementPath.py",
+        "path_type": "hardlink",
+        "sha256": "f2d06f7d3faa0b73f79b45c52d62783cb6b84b75f261c499926cc34509cf02ad",
+        "sha256_in_prefix": "f2d06f7d3faa0b73f79b45c52d62783cb6b84b75f261c499926cc34509cf02ad",
+        "size_in_bytes": 13063
+      },
+      {
+        "_path": "Lib/xml/etree/ElementTree.py",
+        "path_type": "hardlink",
+        "sha256": "9ff69e19c274e4e4d4ba131ce68943d9eaa8dbeaa2f7f685f9966f5cc63f36f0",
+        "sha256_in_prefix": "9ff69e19c274e4e4d4ba131ce68943d9eaa8dbeaa2f7f685f9966f5cc63f36f0",
+        "size_in_bytes": 74404
+      },
+      {
+        "_path": "Lib/xml/etree/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6",
+        "sha256_in_prefix": "91950edfb196c105d93886f8af7ea3c0a79e06a6b63be3e5a4ea09804e8672a6",
+        "size_in_bytes": 1605
+      },
+      {
+        "_path": "Lib/xml/etree/__pycache__/ElementInclude.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3b22e66f7adbac9333b216f1bdcebb0b791e1600b182d6294928868f755f7161",
+        "sha256_in_prefix": "3b22e66f7adbac9333b216f1bdcebb0b791e1600b182d6294928868f755f7161",
+        "size_in_bytes": 2417
+      },
+      {
+        "_path": "Lib/xml/etree/__pycache__/ElementPath.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0bb940e1566ac3679555939ccd7a3c5389895ad0f7c96dddc4dcc0684f182e06",
+        "sha256_in_prefix": "0bb940e1566ac3679555939ccd7a3c5389895ad0f7c96dddc4dcc0684f182e06",
+        "size_in_bytes": 8397
+      },
+      {
+        "_path": "Lib/xml/etree/__pycache__/ElementTree.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9ef4e0611b8c8403b31c83e7eba9be1f8e1d94faf1e20f2f0fbc86bdb252c691",
+        "sha256_in_prefix": "9ef4e0611b8c8403b31c83e7eba9be1f8e1d94faf1e20f2f0fbc86bdb252c691",
+        "size_in_bytes": 56752
+      },
+      {
+        "_path": "Lib/xml/etree/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d5a87c60e94a2068ab153a669e2ae54e3d6298493232d91675e85807da2101e4",
+        "sha256_in_prefix": "d5a87c60e94a2068ab153a669e2ae54e3d6298493232d91675e85807da2101e4",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "Lib/xml/etree/__pycache__/cElementTree.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "97b52ed52eb98a494c2a4bcd822edbfc4965b0618fbc9110a8a629eead9b0fde",
+        "sha256_in_prefix": "97b52ed52eb98a494c2a4bcd822edbfc4965b0618fbc9110a8a629eead9b0fde",
+        "size_in_bytes": 158
+      },
+      {
+        "_path": "Lib/xml/etree/cElementTree.py",
+        "path_type": "hardlink",
+        "sha256": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57",
+        "sha256_in_prefix": "d0f57acab07fe4f9c116c3392d85946bac8e78608f409cea70005f16ea019b57",
+        "size_in_bytes": 82
+      },
+      {
+        "_path": "Lib/xml/parsers/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c",
+        "sha256_in_prefix": "b88497adc30d5d5eda7789c25a2206ee9270c932d584d7ac42680325651da45c",
+        "size_in_bytes": 167
+      },
+      {
+        "_path": "Lib/xml/parsers/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "28bfa1f7ba0911d2c2605bd1b43542be5f27a362796cf422ba399c5b8b482b67",
+        "sha256_in_prefix": "28bfa1f7ba0911d2c2605bd1b43542be5f27a362796cf422ba399c5b8b482b67",
+        "size_in_bytes": 290
+      },
+      {
+        "_path": "Lib/xml/parsers/__pycache__/expat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6449fb3e31acedc2561597d44425b256c2956511852801ff09ba37652393dc9f",
+        "sha256_in_prefix": "6449fb3e31acedc2561597d44425b256c2956511852801ff09ba37652393dc9f",
+        "size_in_bytes": 319
+      },
+      {
+        "_path": "Lib/xml/parsers/expat.py",
+        "path_type": "hardlink",
+        "sha256": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09",
+        "sha256_in_prefix": "64e1947747c2874117a7458bba1f07c86620cc0ed9a4a4116d262878e4a2aa09",
+        "size_in_bytes": 248
+      },
+      {
+        "_path": "Lib/xml/sax/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "4cf987c524aaa6ca2030a59a13a98ea3eae6cd3051099d1dd462d557e7bc7e77",
+        "sha256_in_prefix": "4cf987c524aaa6ca2030a59a13a98ea3eae6cd3051099d1dd462d557e7bc7e77",
+        "size_in_bytes": 3642
+      },
+      {
+        "_path": "Lib/xml/sax/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e4cdc91ca44dbf596499094b3c339cff713de550980f5709260afb9f36219458",
+        "sha256_in_prefix": "e4cdc91ca44dbf596499094b3c339cff713de550980f5709260afb9f36219458",
+        "size_in_bytes": 3183
+      },
+      {
+        "_path": "Lib/xml/sax/__pycache__/_exceptions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a58a44389f0f355faf8f54ee02f72e7ef07d029f04dd83e40a7804c633a8a62e",
+        "sha256_in_prefix": "a58a44389f0f355faf8f54ee02f72e7ef07d029f04dd83e40a7804c633a8a62e",
+        "size_in_bytes": 5429
+      },
+      {
+        "_path": "Lib/xml/sax/__pycache__/expatreader.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2b102b88d5902bb6e587e90d7072baa1e3b39ec940d2f7ab216498530c7e5a8f",
+        "sha256_in_prefix": "2b102b88d5902bb6e587e90d7072baa1e3b39ec940d2f7ab216498530c7e5a8f",
+        "size_in_bytes": 12982
+      },
+      {
+        "_path": "Lib/xml/sax/__pycache__/handler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "da3815958471fda9eafb60c3b6fb9b265089311b6c4db8fc2377e1c3e0217c18",
+        "sha256_in_prefix": "da3815958471fda9eafb60c3b6fb9b265089311b6c4db8fc2377e1c3e0217c18",
+        "size_in_bytes": 12407
+      },
+      {
+        "_path": "Lib/xml/sax/__pycache__/saxutils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b2543af736d13df93325fbb2286ea56df76edeb81a6ecd0e7dfe974df317cfc6",
+        "sha256_in_prefix": "b2543af736d13df93325fbb2286ea56df76edeb81a6ecd0e7dfe974df317cfc6",
+        "size_in_bytes": 12906
+      },
+      {
+        "_path": "Lib/xml/sax/__pycache__/xmlreader.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dc14ea7b808d81ed740f1335463f0567b98dc2520cd454b5440178e64f3f6ca8",
+        "sha256_in_prefix": "dc14ea7b808d81ed740f1335463f0567b98dc2520cd454b5440178e64f3f6ca8",
+        "size_in_bytes": 16829
+      },
+      {
+        "_path": "Lib/xml/sax/_exceptions.py",
+        "path_type": "hardlink",
+        "sha256": "cfa45778e457731e0988d9ceef29cf9eeef916f22d7bd53f4cb08c7a2b8b2ce2",
+        "sha256_in_prefix": "cfa45778e457731e0988d9ceef29cf9eeef916f22d7bd53f4cb08c7a2b8b2ce2",
+        "size_in_bytes": 4785
+      },
+      {
+        "_path": "Lib/xml/sax/expatreader.py",
+        "path_type": "hardlink",
+        "sha256": "4ee774e2d0a3efe1cd1a1afdb3778f6a95523c79bc940ddfd40c19592ba7be21",
+        "sha256_in_prefix": "4ee774e2d0a3efe1cd1a1afdb3778f6a95523c79bc940ddfd40c19592ba7be21",
+        "size_in_bytes": 16211
+      },
+      {
+        "_path": "Lib/xml/sax/handler.py",
+        "path_type": "hardlink",
+        "sha256": "5882e7a08f97768b63370b2fe2d557d573708494fcb79d068d3e7807b53f4e15",
+        "sha256_in_prefix": "5882e7a08f97768b63370b2fe2d557d573708494fcb79d068d3e7807b53f4e15",
+        "size_in_bytes": 13922
+      },
+      {
+        "_path": "Lib/xml/sax/saxutils.py",
+        "path_type": "hardlink",
+        "sha256": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab",
+        "sha256_in_prefix": "3fe2cdb6386e0c4d42d37c657bbecb78b69c57aedb1610dbd8bf4043944130ab",
+        "size_in_bytes": 12255
+      },
+      {
+        "_path": "Lib/xml/sax/xmlreader.py",
+        "path_type": "hardlink",
+        "sha256": "922a6e2995952366b366c13736d715d77fa1868ee453fdabe35043059357768f",
+        "sha256_in_prefix": "922a6e2995952366b366c13736d715d77fa1868ee453fdabe35043059357768f",
+        "size_in_bytes": 12684
+      },
+      {
+        "_path": "Lib/xmlrpc/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8",
+        "sha256_in_prefix": "87ad5c8954dd56fbbca04517bf87477ff4dce575170c7dd1281d7ef1f4214ac8",
+        "size_in_bytes": 38
+      },
+      {
+        "_path": "Lib/xmlrpc/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4b9eae448534b02fdfffdc9f627ad3e58022dd2d81b233f26c129d2a290e0b4a",
+        "sha256_in_prefix": "4b9eae448534b02fdfffdc9f627ad3e58022dd2d81b233f26c129d2a290e0b4a",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "Lib/xmlrpc/__pycache__/client.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "32dab01ce26a134d587d57909519e862f4ec73e763e74281fbcb2fc64b9ed15a",
+        "sha256_in_prefix": "32dab01ce26a134d587d57909519e862f4ec73e763e74281fbcb2fc64b9ed15a",
+        "size_in_bytes": 34697
+      },
+      {
+        "_path": "Lib/xmlrpc/__pycache__/server.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7008d38a2ad33dbf79759dd3d4438b48c17a17bf6a9dbfff09e734e607633bee",
+        "sha256_in_prefix": "7008d38a2ad33dbf79759dd3d4438b48c17a17bf6a9dbfff09e734e607633bee",
+        "size_in_bytes": 29358
+      },
+      {
+        "_path": "Lib/xmlrpc/client.py",
+        "path_type": "hardlink",
+        "sha256": "2e6d11a76a1d1f360655e251466ec192843a6bdac1e97bd88dcd358b3045adcd",
+        "sha256_in_prefix": "2e6d11a76a1d1f360655e251466ec192843a6bdac1e97bd88dcd358b3045adcd",
+        "size_in_bytes": 49391
+      },
+      {
+        "_path": "Lib/xmlrpc/server.py",
+        "path_type": "hardlink",
+        "sha256": "7a0f492dccca9cc8027800815be42053c3a9bd74569d48b7113696e5c3f699aa",
+        "sha256_in_prefix": "7a0f492dccca9cc8027800815be42053c3a9bd74569d48b7113696e5c3f699aa",
+        "size_in_bytes": 36672
+      },
+      {
+        "_path": "Lib/zipapp.py",
+        "path_type": "hardlink",
+        "sha256": "776078e89fd7dadbce41678f8bacd3b493135e6d610911c867489415420de383",
+        "sha256_in_prefix": "776078e89fd7dadbce41678f8bacd3b493135e6d610911c867489415420de383",
+        "size_in_bytes": 7535
+      },
+      {
+        "_path": "Lib/zipfile.py",
+        "path_type": "hardlink",
+        "sha256": "fbe9376e7db833842a8148597b0049ec058f7a6278b98eac19b255b3e39db515",
+        "sha256_in_prefix": "fbe9376e7db833842a8148597b0049ec058f7a6278b98eac19b255b3e39db515",
+        "size_in_bytes": 88240
+      },
+      {
+        "_path": "Lib/zipimport.py",
+        "path_type": "hardlink",
+        "sha256": "8f9a84b7d8f9ef72dd47827a9c4e4663980030eebd5d4d52cda864aa18db5aba",
+        "sha256_in_prefix": "8f9a84b7d8f9ef72dd47827a9c4e4663980030eebd5d4d52cda864aa18db5aba",
+        "size_in_bytes": 30835
+      },
+      {
+        "_path": "Lib/zoneinfo/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8",
+        "sha256_in_prefix": "ac7fb403e4371d07482ef2fda81dbcf6879484e9fc41d4be42c156d7e54c68a8",
+        "size_in_bytes": 703
+      },
+      {
+        "_path": "Lib/zoneinfo/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "df166e55368e2d08aeb06dc53cd48afd7d75e9330c587d47839dc8fb14a53c53",
+        "sha256_in_prefix": "df166e55368e2d08aeb06dc53cd48afd7d75e9330c587d47839dc8fb14a53c53",
+        "size_in_bytes": 794
+      },
+      {
+        "_path": "Lib/zoneinfo/__pycache__/_common.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "004255677ebda7e9302976853129f0d26a21c36e3bdc54c89d887da1b11be2dd",
+        "sha256_in_prefix": "004255677ebda7e9302976853129f0d26a21c36e3bdc54c89d887da1b11be2dd",
+        "size_in_bytes": 3089
+      },
+      {
+        "_path": "Lib/zoneinfo/__pycache__/_tzpath.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c61bfd0b805f725401d73e2f5073c3795377a2f1cff53011ebe588a495600509",
+        "sha256_in_prefix": "c61bfd0b805f725401d73e2f5073c3795377a2f1cff53011ebe588a495600509",
+        "size_in_bytes": 4030
+      },
+      {
+        "_path": "Lib/zoneinfo/__pycache__/_zoneinfo.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c1828bc9a473f172311276f74d4a61970db5d2e65f92974283c196e3f2890181",
+        "sha256_in_prefix": "c1828bc9a473f172311276f74d4a61970db5d2e65f92974283c196e3f2890181",
+        "size_in_bytes": 15451
+      },
+      {
+        "_path": "Lib/zoneinfo/_common.py",
+        "path_type": "hardlink",
+        "sha256": "240965ebd66fac3d91dcbcaea6fab0f6bfec0e5f7239708e0a916c4e5a5976ce",
+        "sha256_in_prefix": "240965ebd66fac3d91dcbcaea6fab0f6bfec0e5f7239708e0a916c4e5a5976ce",
+        "size_in_bytes": 5320
+      },
+      {
+        "_path": "Lib/zoneinfo/_tzpath.py",
+        "path_type": "hardlink",
+        "sha256": "3896a3dfd0d7d6e1812d071952590e5365c9b41938a777f596a7ad0eef2d3704",
+        "sha256_in_prefix": "3896a3dfd0d7d6e1812d071952590e5365c9b41938a777f596a7ad0eef2d3704",
+        "size_in_bytes": 5081
+      },
+      {
+        "_path": "Lib/zoneinfo/_zoneinfo.py",
+        "path_type": "hardlink",
+        "sha256": "86ea56c26f16cff63c761878ebb1e4535312f32f6e9598d22111f056d12f6c78",
+        "sha256_in_prefix": "86ea56c26f16cff63c761878ebb1e4535312f32f6e9598d22111f056d12f6c78",
+        "size_in_bytes": 24318
+      },
+      {
+        "_path": "Scripts/2to3-script.py",
+        "path_type": "hardlink",
+        "sha256": "cd4c36af54383d8c7103721fb491e5b0a5f5d7c71b85456d6a894bd61f1eb092",
+        "sha256_in_prefix": "cd4c36af54383d8c7103721fb491e5b0a5f5d7c71b85456d6a894bd61f1eb092",
+        "size_in_bytes": 74
+      },
+      {
+        "_path": "Scripts/2to3.exe",
+        "path_type": "hardlink",
+        "sha256": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "sha256_in_prefix": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "size_in_bytes": 54032
+      },
+      {
+        "_path": "Scripts/idle-script.py",
+        "path_type": "hardlink",
+        "sha256": "d43ef2f45ffd2551b678003ade97d9b4a17413c322935571c006d2871d96e8f6",
+        "sha256_in_prefix": "d43ef2f45ffd2551b678003ade97d9b4a17413c322935571c006d2871d96e8f6",
+        "size_in_bytes": 72
+      },
+      {
+        "_path": "Scripts/idle.exe",
+        "path_type": "hardlink",
+        "sha256": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "sha256_in_prefix": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "size_in_bytes": 54032
+      },
+      {
+        "_path": "Scripts/pydoc-script.py",
+        "path_type": "hardlink",
+        "sha256": "61515cdba67a1834887d8dc57507788ef40253c58c2c8c95596d52a80694ae06",
+        "sha256_in_prefix": "61515cdba67a1834887d8dc57507788ef40253c58c2c8c95596d52a80694ae06",
+        "size_in_bytes": 57
+      },
+      {
+        "_path": "Scripts/pydoc.exe",
+        "path_type": "hardlink",
+        "sha256": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "sha256_in_prefix": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "size_in_bytes": 54032
+      },
+      {
+        "_path": "Tools/demo/__pycache__/beer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5ffcebf70257d9064e1767c0825a982df1f30388267cb8105e234e94bd9e8e8e",
+        "sha256_in_prefix": "5ffcebf70257d9064e1767c0825a982df1f30388267cb8105e234e94bd9e8e8e",
+        "size_in_bytes": 738
+      },
+      {
+        "_path": "Tools/demo/__pycache__/eiffel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1d945618740e855c749de17923204029dd301c57e9bd1ca5ef1a2242334a8f78",
+        "sha256_in_prefix": "1d945618740e855c749de17923204029dd301c57e9bd1ca5ef1a2242334a8f78",
+        "size_in_bytes": 5643
+      },
+      {
+        "_path": "Tools/demo/__pycache__/hanoi.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6b73fba8c09c777df92dedc93e10cc55835960bc488a186a4a386e7c3784f619",
+        "sha256_in_prefix": "6b73fba8c09c777df92dedc93e10cc55835960bc488a186a4a386e7c3784f619",
+        "size_in_bytes": 3335
+      },
+      {
+        "_path": "Tools/demo/__pycache__/life.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6d24a5362e4d48a4723538653b2a4e95932b9aa3b8413248a95a0ccc078be4cf",
+        "sha256_in_prefix": "6d24a5362e4d48a4723538653b2a4e95932b9aa3b8413248a95a0ccc078be4cf",
+        "size_in_bytes": 6722
+      },
+      {
+        "_path": "Tools/demo/__pycache__/markov.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "731153f09d8e40bcc862c9e634b18f92113cd7a8145414a51addc3738cc6b893",
+        "sha256_in_prefix": "731153f09d8e40bcc862c9e634b18f92113cd7a8145414a51addc3738cc6b893",
+        "size_in_bytes": 3341
+      },
+      {
+        "_path": "Tools/demo/__pycache__/mcast.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ae7b2b86b2e8f3217c915434e94da623ad14c2dc133eab070d6fe63c664dd5c8",
+        "sha256_in_prefix": "ae7b2b86b2e8f3217c915434e94da623ad14c2dc133eab070d6fe63c664dd5c8",
+        "size_in_bytes": 1903
+      },
+      {
+        "_path": "Tools/demo/__pycache__/queens.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e12def37b2349f578b025ab9a4606d9ba3398d3f4fd5a02f0537c02ff65d284e",
+        "sha256_in_prefix": "e12def37b2349f578b025ab9a4606d9ba3398d3f4fd5a02f0537c02ff65d284e",
+        "size_in_bytes": 2409
+      },
+      {
+        "_path": "Tools/demo/__pycache__/redemo.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6a10edf2842b56d28bd5f876853209fe45412089d6b4053d94b8c3f875d13464",
+        "sha256_in_prefix": "6a10edf2842b56d28bd5f876853209fe45412089d6b4053d94b8c3f875d13464",
+        "size_in_bytes": 4105
+      },
+      {
+        "_path": "Tools/demo/__pycache__/rpython.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "60ff227baae8f3d81c6b38e7a2bb7bf5e1e965371bf115c2644991abe49b1608",
+        "sha256_in_prefix": "60ff227baae8f3d81c6b38e7a2bb7bf5e1e965371bf115c2644991abe49b1608",
+        "size_in_bytes": 957
+      },
+      {
+        "_path": "Tools/demo/__pycache__/rpythond.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f25085faa66ee0bcd59b7a03a1c77b07c2a6a3a35e17a12bb78fbcaa699183ef",
+        "sha256_in_prefix": "f25085faa66ee0bcd59b7a03a1c77b07c2a6a3a35e17a12bb78fbcaa699183ef",
+        "size_in_bytes": 1375
+      },
+      {
+        "_path": "Tools/demo/__pycache__/sortvisu.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1af9e089c006b7e048676bd50bf7cd847cc4f991878128268070aeb02cae0f65",
+        "sha256_in_prefix": "1af9e089c006b7e048676bd50bf7cd847cc4f991878128268070aeb02cae0f65",
+        "size_in_bytes": 18678
+      },
+      {
+        "_path": "Tools/demo/__pycache__/spreadsheet.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "00442698d4186e2cfb5ac91f175bc869efe46daa373079b273c7f004561e0bfe",
+        "sha256_in_prefix": "00442698d4186e2cfb5ac91f175bc869efe46daa373079b273c7f004561e0bfe",
+        "size_in_bytes": 24919
+      },
+      {
+        "_path": "Tools/demo/__pycache__/vector.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "62f67bfd0d9e6a66e49ab61b74f680086db5acf8e046d6ab8caa9d15f13d8f83",
+        "sha256_in_prefix": "62f67bfd0d9e6a66e49ab61b74f680086db5acf8e046d6ab8caa9d15f13d8f83",
+        "size_in_bytes": 2705
+      },
+      {
+        "_path": "Tools/demo/beer.py",
+        "path_type": "hardlink",
+        "sha256": "ad664a7ea177192866b365f05528d2f67ee85f52da720ff84776dd082122767e",
+        "sha256_in_prefix": "ad664a7ea177192866b365f05528d2f67ee85f52da720ff84776dd082122767e",
+        "size_in_bytes": 566
+      },
+      {
+        "_path": "Tools/demo/eiffel.py",
+        "path_type": "hardlink",
+        "sha256": "00a896d378b3749d27cc05322e6dfb6243edf79feec6ca2e0f0f0e23ebf60d62",
+        "sha256_in_prefix": "00a896d378b3749d27cc05322e6dfb6243edf79feec6ca2e0f0f0e23ebf60d62",
+        "size_in_bytes": 3911
+      },
+      {
+        "_path": "Tools/demo/hanoi.py",
+        "path_type": "hardlink",
+        "sha256": "b2006267403cd4b97a8d289d343bb82cc34c03bd357f1aefc441135b05c6a41f",
+        "sha256_in_prefix": "b2006267403cd4b97a8d289d343bb82cc34c03bd357f1aefc441135b05c6a41f",
+        "size_in_bytes": 4611
+      },
+      {
+        "_path": "Tools/demo/life.py",
+        "path_type": "hardlink",
+        "sha256": "6a5a27e3028d4a5ff7a57d950d98d7ef71052bfb2fb2bd10d7bf648f9f217aa9",
+        "sha256_in_prefix": "6a5a27e3028d4a5ff7a57d950d98d7ef71052bfb2fb2bd10d7bf648f9f217aa9",
+        "size_in_bytes": 8987
+      },
+      {
+        "_path": "Tools/demo/markov.py",
+        "path_type": "hardlink",
+        "sha256": "58f6474aeaec81fd0f15fe0757f0ffc15fcf9a31e102c95931c9d1f2cab2b77b",
+        "sha256_in_prefix": "58f6474aeaec81fd0f15fe0757f0ffc15fcf9a31e102c95931c9d1f2cab2b77b",
+        "size_in_bytes": 3691
+      },
+      {
+        "_path": "Tools/demo/mcast.py",
+        "path_type": "hardlink",
+        "sha256": "748f27fbf0678c2624b990c4523c071b3bf8fdc06a1e93dbbaf29c90dd92a210",
+        "sha256_in_prefix": "748f27fbf0678c2624b990c4523c071b3bf8fdc06a1e93dbbaf29c90dd92a210",
+        "size_in_bytes": 2223
+      },
+      {
+        "_path": "Tools/demo/queens.py",
+        "path_type": "hardlink",
+        "sha256": "fa92dfad7091c7b9c6cc53db28881613887f046b43b648a8aa33a60d664416ac",
+        "sha256_in_prefix": "fa92dfad7091c7b9c6cc53db28881613887f046b43b648a8aa33a60d664416ac",
+        "size_in_bytes": 2270
+      },
+      {
+        "_path": "Tools/demo/redemo.py",
+        "path_type": "hardlink",
+        "sha256": "ae01f5ba375b31b2e028f4696cb01d32061366e111f9fa3187474f6a9bce09a5",
+        "sha256_in_prefix": "ae01f5ba375b31b2e028f4696cb01d32061366e111f9fa3187474f6a9bce09a5",
+        "size_in_bytes": 5749
+      },
+      {
+        "_path": "Tools/demo/rpython.py",
+        "path_type": "hardlink",
+        "sha256": "56ef31c650cd1894473f3feb1a06015bddb1b5b8c87ba044776abcc64267d031",
+        "sha256_in_prefix": "56ef31c650cd1894473f3feb1a06015bddb1b5b8c87ba044776abcc64267d031",
+        "size_in_bytes": 811
+      },
+      {
+        "_path": "Tools/demo/rpythond.py",
+        "path_type": "hardlink",
+        "sha256": "0ef1b388290b56cd976fa09df78ffc924fd06c1a8150783491770a0baf9c0843",
+        "sha256_in_prefix": "0ef1b388290b56cd976fa09df78ffc924fd06c1a8150783491770a0baf9c0843",
+        "size_in_bytes": 1323
+      },
+      {
+        "_path": "Tools/demo/sortvisu.py",
+        "path_type": "hardlink",
+        "sha256": "0d18f75930a6940d43bb4921f17a76bb9f60a532f033045f09b8e4e3dd3d4083",
+        "sha256_in_prefix": "0d18f75930a6940d43bb4921f17a76bb9f60a532f033045f09b8e4e3dd3d4083",
+        "size_in_bytes": 19987
+      },
+      {
+        "_path": "Tools/demo/spreadsheet.py",
+        "path_type": "hardlink",
+        "sha256": "e2ce5c8d4c44cc2dbc67453ea1c9ea62e467bb0d2ff46742430b7c6e977cddf0",
+        "sha256_in_prefix": "e2ce5c8d4c44cc2dbc67453ea1c9ea62e467bb0d2ff46742430b7c6e977cddf0",
+        "size_in_bytes": 25623
+      },
+      {
+        "_path": "Tools/demo/vector.py",
+        "path_type": "hardlink",
+        "sha256": "a296ede8e9ae052fae93b9e8d5e31ff1b27348e02e9cbca1b0c649e15ac0bef3",
+        "sha256_in_prefix": "a296ede8e9ae052fae93b9e8d5e31ff1b27348e02e9cbca1b0c649e15ac0bef3",
+        "size_in_bytes": 1452
+      },
+      {
+        "_path": "Tools/i18n/__pycache__/makelocalealias.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9977fa0f10be0344ba447abd33f102b43a794b4fc575ae25a8d063f7b33e0a45",
+        "sha256_in_prefix": "9977fa0f10be0344ba447abd33f102b43a794b4fc575ae25a8d063f7b33e0a45",
+        "size_in_bytes": 3614
+      },
+      {
+        "_path": "Tools/i18n/__pycache__/msgfmt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9c1da72c9e961c9f3e590bb357dd2a54977258f006ca6f45f381ba47fb4f758b",
+        "sha256_in_prefix": "9c1da72c9e961c9f3e590bb357dd2a54977258f006ca6f45f381ba47fb4f758b",
+        "size_in_bytes": 4735
+      },
+      {
+        "_path": "Tools/i18n/__pycache__/pygettext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "37e4a860e3d2b33f89ec0752e7709c0078bb588336111e6fb4c5a95a63caa150",
+        "sha256_in_prefix": "37e4a860e3d2b33f89ec0752e7709c0078bb588336111e6fb4c5a95a63caa150",
+        "size_in_bytes": 16325
+      },
+      {
+        "_path": "Tools/i18n/makelocalealias.py",
+        "path_type": "hardlink",
+        "sha256": "8cfc9a27d3cc32cf3b8a8f58b6d5b18717e6e1786a958312c168b741d485ed9d",
+        "sha256_in_prefix": "8cfc9a27d3cc32cf3b8a8f58b6d5b18717e6e1786a958312c168b741d485ed9d",
+        "size_in_bytes": 5029
+      },
+      {
+        "_path": "Tools/i18n/msgfmt.py",
+        "path_type": "hardlink",
+        "sha256": "79c83d2646e7cf742226b52c989431cea1b08749adbb599fba001bb0203efe1f",
+        "sha256_in_prefix": "79c83d2646e7cf742226b52c989431cea1b08749adbb599fba001bb0203efe1f",
+        "size_in_bytes": 7592
+      },
+      {
+        "_path": "Tools/i18n/pygettext.py",
+        "path_type": "hardlink",
+        "sha256": "2e9492449f58e64938e2798625f3ccc2a081de2ad7036279d64c5ab2670641c5",
+        "sha256_in_prefix": "2e9492449f58e64938e2798625f3ccc2a081de2ad7036279d64c5ab2670641c5",
+        "size_in_bytes": 21539
+      },
+      {
+        "_path": "Tools/pynche/ChipViewer.py",
+        "path_type": "hardlink",
+        "sha256": "d58e84e196fd0f859c58df779ba89b8a8dffc736fbe7466230a12ea1cc07c986",
+        "sha256_in_prefix": "d58e84e196fd0f859c58df779ba89b8a8dffc736fbe7466230a12ea1cc07c986",
+        "size_in_bytes": 4998
+      },
+      {
+        "_path": "Tools/pynche/ColorDB.py",
+        "path_type": "hardlink",
+        "sha256": "177ffcb6f3714202703d8c763b154148bd4407d384854753babd357a0471d0b8",
+        "sha256_in_prefix": "177ffcb6f3714202703d8c763b154148bd4407d384854753babd357a0471d0b8",
+        "size_in_bytes": 8804
+      },
+      {
+        "_path": "Tools/pynche/DetailsViewer.py",
+        "path_type": "hardlink",
+        "sha256": "e9ccd679b6afe6383dbd0bdfb65d82e82d1f9e5e036cb0b9d3b1995bf3af5824",
+        "sha256_in_prefix": "e9ccd679b6afe6383dbd0bdfb65d82e82d1f9e5e036cb0b9d3b1995bf3af5824",
+        "size_in_bytes": 10116
+      },
+      {
+        "_path": "Tools/pynche/ListViewer.py",
+        "path_type": "hardlink",
+        "sha256": "e1ccfaea7c54706082fe95692ebf4c64d20d0deff81e5dcafceacd41a309fddc",
+        "sha256_in_prefix": "e1ccfaea7c54706082fe95692ebf4c64d20d0deff81e5dcafceacd41a309fddc",
+        "size_in_bytes": 6648
+      },
+      {
+        "_path": "Tools/pynche/Main.py",
+        "path_type": "hardlink",
+        "sha256": "4210e13b7c1d435fe3f0c29be9973f6bd663b6834def6153bc4334bb1d273f2e",
+        "sha256_in_prefix": "4210e13b7c1d435fe3f0c29be9973f6bd663b6834def6153bc4334bb1d273f2e",
+        "size_in_bytes": 6406
+      },
+      {
+        "_path": "Tools/pynche/PyncheWidget.py",
+        "path_type": "hardlink",
+        "sha256": "b1c01ed87adb8b5788f66f046cc54766536fbbcd2542f069f0c8da46183a3ec6",
+        "sha256_in_prefix": "b1c01ed87adb8b5788f66f046cc54766536fbbcd2542f069f0c8da46183a3ec6",
+        "size_in_bytes": 10645
+      },
+      {
+        "_path": "Tools/pynche/StripViewer.py",
+        "path_type": "hardlink",
+        "sha256": "dbc5c75ebe04610d11e5b46c2a494be92c21cef28d81ebaadd6ab3f9ad1e51c7",
+        "sha256_in_prefix": "dbc5c75ebe04610d11e5b46c2a494be92c21cef28d81ebaadd6ab3f9ad1e51c7",
+        "size_in_bytes": 13689
+      },
+      {
+        "_path": "Tools/pynche/Switchboard.py",
+        "path_type": "hardlink",
+        "sha256": "837cacbab8e88147f6fee4c55385d336d1e21af438e98f9531ac6aedc8dd0f42",
+        "sha256_in_prefix": "837cacbab8e88147f6fee4c55385d336d1e21af438e98f9531ac6aedc8dd0f42",
+        "size_in_bytes": 4797
+      },
+      {
+        "_path": "Tools/pynche/TextViewer.py",
+        "path_type": "hardlink",
+        "sha256": "ba3511af7bd98495f8a489e97aa276e675999ea180339f6a0c06d00caf6eebf7",
+        "sha256_in_prefix": "ba3511af7bd98495f8a489e97aa276e675999ea180339f6a0c06d00caf6eebf7",
+        "size_in_bytes": 6869
+      },
+      {
+        "_path": "Tools/pynche/TypeinViewer.py",
+        "path_type": "hardlink",
+        "sha256": "ae01e5a661fe26bcb34023496d8e9a749668cfcc2606b16a86088891955ae6ed",
+        "sha256_in_prefix": "ae01e5a661fe26bcb34023496d8e9a749668cfcc2606b16a86088891955ae6ed",
+        "size_in_bytes": 6102
+      },
+      {
+        "_path": "Tools/pynche/X/rgb.txt",
+        "path_type": "hardlink",
+        "sha256": "af6c056a95ae725f98534db22b9a4916d17f2356fdca84a4a038211a82fa8a73",
+        "sha256_in_prefix": "af6c056a95ae725f98534db22b9a4916d17f2356fdca84a4a038211a82fa8a73",
+        "size_in_bytes": 17375
+      },
+      {
+        "_path": "Tools/pynche/X/xlicense.txt",
+        "path_type": "hardlink",
+        "sha256": "50ca2b67ad509c248d9a0137ff7ca214476c2d0f63625e3491dd65d0f283e44e",
+        "sha256_in_prefix": "50ca2b67ad509c248d9a0137ff7ca214476c2d0f63625e3491dd65d0f283e44e",
+        "size_in_bytes": 1352
+      },
+      {
+        "_path": "Tools/pynche/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9",
+        "sha256_in_prefix": "836cdb388117cf81e78d9fa2a141cca1b14b0179733322e710067749a1b16fe9",
+        "size_in_bytes": 47
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/ChipViewer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ecb8805703b976f92fc2f1fcf16ed1320a36e3ffdc793a0673959d1b20304a93",
+        "sha256_in_prefix": "ecb8805703b976f92fc2f1fcf16ed1320a36e3ffdc793a0673959d1b20304a93",
+        "size_in_bytes": 4403
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/ColorDB.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9f812daba47a8d03484bb9ea3202a8b56a3abfb32b2ea3d6c0f1c9ca6b106814",
+        "sha256_in_prefix": "9f812daba47a8d03484bb9ea3202a8b56a3abfb32b2ea3d6c0f1c9ca6b106814",
+        "size_in_bytes": 7712
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/DetailsViewer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "48bb7792cd9cd62d9d9400d72798dafabac022ea84c755718e3aab93a400c8ac",
+        "sha256_in_prefix": "48bb7792cd9cd62d9d9400d72798dafabac022ea84c755718e3aab93a400c8ac",
+        "size_in_bytes": 8643
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/ListViewer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ba8022a852c40370ff7cc450351f95e4930e23f9d0e19021d70b477ed8179637",
+        "sha256_in_prefix": "ba8022a852c40370ff7cc450351f95e4930e23f9d0e19021d70b477ed8179637",
+        "size_in_bytes": 5842
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/Main.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5d4317a3a17665f8ad9ef74887003b495084ad19b9998573c663d9326a9ae11f",
+        "sha256_in_prefix": "5d4317a3a17665f8ad9ef74887003b495084ad19b9998573c663d9326a9ae11f",
+        "size_in_bytes": 5116
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/PyncheWidget.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eb559583c6a04f9c80f93c511454cf4985bc60dd8373de6c121eef0302fd4d89",
+        "sha256_in_prefix": "eb559583c6a04f9c80f93c511454cf4985bc60dd8373de6c121eef0302fd4d89",
+        "size_in_bytes": 8836
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/StripViewer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "691a6107796b3c4941f155e80856c29de87a2030a3ab6ceb7db33f08f1fdea32",
+        "sha256_in_prefix": "691a6107796b3c4941f155e80856c29de87a2030a3ab6ceb7db33f08f1fdea32",
+        "size_in_bytes": 10786
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/Switchboard.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "243e6a3c2d2e2f5a78e9b24c4f385c0e2a720447a0ce505969ac10eecfb35ad8",
+        "sha256_in_prefix": "243e6a3c2d2e2f5a78e9b24c4f385c0e2a720447a0ce505969ac10eecfb35ad8",
+        "size_in_bytes": 5210
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/TextViewer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "41fd41de500d91012af2be9d91d9aa49df0a279267ef3c24fca4df6f3dbcea7c",
+        "sha256_in_prefix": "41fd41de500d91012af2be9d91d9aa49df0a279267ef3c24fca4df6f3dbcea7c",
+        "size_in_bytes": 5963
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/TypeinViewer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a3d9bdf5f257ff558f4fe4dc6995802771cd84a70f3414e069cdaa84a0bcbe96",
+        "sha256_in_prefix": "a3d9bdf5f257ff558f4fe4dc6995802771cd84a70f3414e069cdaa84a0bcbe96",
+        "size_in_bytes": 5342
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "183045541beeaf781974e2185fd0efdaf055495dd76d3f13f348710644513bc3",
+        "sha256_in_prefix": "183045541beeaf781974e2185fd0efdaf055495dd76d3f13f348710644513bc3",
+        "size_in_bytes": 115
+      },
+      {
+        "_path": "Tools/pynche/__pycache__/pyColorChooser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7fdd3c8138d130100f43d976eeda4a390b61856dbf3629d3a2d5e995cc288f4c",
+        "sha256_in_prefix": "7fdd3c8138d130100f43d976eeda4a390b61856dbf3629d3a2d5e995cc288f4c",
+        "size_in_bytes": 3254
+      },
+      {
+        "_path": "Tools/pynche/html40colors.txt",
+        "path_type": "hardlink",
+        "sha256": "f41008bc9423d44d4d8a8be25eb6835bcba82653f9a823d2afe7619039483e5c",
+        "sha256_in_prefix": "f41008bc9423d44d4d8a8be25eb6835bcba82653f9a823d2afe7619039483e5c",
+        "size_in_bytes": 245
+      },
+      {
+        "_path": "Tools/pynche/namedcolors.txt",
+        "path_type": "hardlink",
+        "sha256": "4f8d8b62c1ffcd18bfef84491b9bc273e044a7016f7448229cf1be3094c6d48f",
+        "sha256_in_prefix": "4f8d8b62c1ffcd18bfef84491b9bc273e044a7016f7448229cf1be3094c6d48f",
+        "size_in_bytes": 5716
+      },
+      {
+        "_path": "Tools/pynche/pyColorChooser.py",
+        "path_type": "hardlink",
+        "sha256": "ce1584fb838cbc4c91208c686acaa25cd11f0db45a0ba41da6c7a5bf6bfcb3f1",
+        "sha256_in_prefix": "ce1584fb838cbc4c91208c686acaa25cd11f0db45a0ba41da6c7a5bf6bfcb3f1",
+        "size_in_bytes": 3759
+      },
+      {
+        "_path": "Tools/pynche/pynche.pyw",
+        "path_type": "hardlink",
+        "sha256": "8b6fbf8816d2c92a2d9ccebb14fbf9d562ed7ea12699b31ab86f97261b7aff3f",
+        "sha256_in_prefix": "8b6fbf8816d2c92a2d9ccebb14fbf9d562ed7ea12699b31ab86f97261b7aff3f",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "Tools/pynche/webcolors.txt",
+        "path_type": "hardlink",
+        "sha256": "40fc35ccf29d0e3efbeeba45f63fb3b51d39a16cfed2fa5e460d497b555f9304",
+        "sha256_in_prefix": "40fc35ccf29d0e3efbeeba45f63fb3b51d39a16cfed2fa5e460d497b555f9304",
+        "size_in_bytes": 3088
+      },
+      {
+        "_path": "Tools/pynche/websafe.txt",
+        "path_type": "hardlink",
+        "sha256": "e575fe1ed0424f31764b3fc7572df06756e40e5212f85c97bc07b60d1aee8935",
+        "sha256_in_prefix": "e575fe1ed0424f31764b3fc7572df06756e40e5212f85c97bc07b60d1aee8935",
+        "size_in_bytes": 1749
+      },
+      {
+        "_path": "Tools/scripts/2to3.py",
+        "path_type": "hardlink",
+        "sha256": "20033343a6830afdb6824aea0963201af5b42b81ff9ac576826190f3e56437b6",
+        "sha256_in_prefix": "20033343a6830afdb6824aea0963201af5b42b81ff9ac576826190f3e56437b6",
+        "size_in_bytes": 96
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/2to3.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "61643c37ca626a2d903970b8a8174009f8351cb83b51faaa345b9efb74c7530d",
+        "sha256_in_prefix": "61643c37ca626a2d903970b8a8174009f8351cb83b51faaa345b9efb74c7530d",
+        "size_in_bytes": 205
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/abitype.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "72e733d7294d01c6b04c060fd4dab29aaffe7c7e23e342a1f5c4591619909a01",
+        "sha256_in_prefix": "72e733d7294d01c6b04c060fd4dab29aaffe7c7e23e342a1f5c4591619909a01",
+        "size_in_bytes": 3385
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/analyze_dxp.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1b1eb92331b041241bc1c2f373138cfa4a4a1f73ef33446d15a3c4f66aaa3d36",
+        "sha256_in_prefix": "1b1eb92331b041241bc1c2f373138cfa4a4a1f73ef33446d15a3c4f66aaa3d36",
+        "size_in_bytes": 4285
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/byext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a46fc527f81bfb27a42a1c1bb5d4b2a161330db552936fee434a4ffca2868449",
+        "sha256_in_prefix": "a46fc527f81bfb27a42a1c1bb5d4b2a161330db552936fee434a4ffca2868449",
+        "size_in_bytes": 3456
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/byteyears.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8694c7cbc56e3ce8e01cfa0e9f87da94225d15c0d861f9b66cbdbfeee8be9afc",
+        "sha256_in_prefix": "8694c7cbc56e3ce8e01cfa0e9f87da94225d15c0d861f9b66cbdbfeee8be9afc",
+        "size_in_bytes": 1085
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/checkpip.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7ccb1b0ac0093f7b903cd1f585c619192a115afc7a754f36c9fe4684cff4edc0",
+        "sha256_in_prefix": "7ccb1b0ac0093f7b903cd1f585c619192a115afc7a754f36c9fe4684cff4edc0",
+        "size_in_bytes": 865
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/cleanfuture.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "94959dc51d545642f58c0b53c3ea21a03e421ab96283f6b314fdeae2739200ec",
+        "sha256_in_prefix": "94959dc51d545642f58c0b53c3ea21a03e421ab96283f6b314fdeae2739200ec",
+        "size_in_bytes": 6107
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/combinerefs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c3ab6331fe71a735fab6439b614e5b7a6cb5453e535699a5fb2eae89afe1f676",
+        "sha256_in_prefix": "c3ab6331fe71a735fab6439b614e5b7a6cb5453e535699a5fb2eae89afe1f676",
+        "size_in_bytes": 4027
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/copytime.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2a0cedf36faa265dc58f697e35fcec385acd11c76baaebff00981fbfae58738e",
+        "sha256_in_prefix": "2a0cedf36faa265dc58f697e35fcec385acd11c76baaebff00981fbfae58738e",
+        "size_in_bytes": 735
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/crlf.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d67970b459a80b4d9e19d25ffede92dd79503c71adf8a899309aaf47695c30dc",
+        "sha256_in_prefix": "d67970b459a80b4d9e19d25ffede92dd79503c71adf8a899309aaf47695c30dc",
+        "size_in_bytes": 722
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/db2pickle.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e90944260e702ec92b53946cdd06589cfe10cd72de552350a0019aa9ace6ee60",
+        "sha256_in_prefix": "e90944260e702ec92b53946cdd06589cfe10cd72de552350a0019aa9ace6ee60",
+        "size_in_bytes": 2892
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/diff.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9a2a7b44d00a08548881ad762495da472b0dfeb6c5162507c957f90c8e7740e1",
+        "sha256_in_prefix": "9a2a7b44d00a08548881ad762495da472b0dfeb6c5162507c957f90c8e7740e1",
+        "size_in_bytes": 2008
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/dutree.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "83c79e0d0a7329f2f9f4abc80f860ae716934e3a6bd7a48ab9939ac77e2e2173",
+        "sha256_in_prefix": "83c79e0d0a7329f2f9f4abc80f860ae716934e3a6bd7a48ab9939ac77e2e2173",
+        "size_in_bytes": 1661
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/eptags.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5895d4935dd1faea329a5f2c4610b70fa1e79c38aa3dfb9d84f5f2307890f6ef",
+        "sha256_in_prefix": "5895d4935dd1faea329a5f2c4610b70fa1e79c38aa3dfb9d84f5f2307890f6ef",
+        "size_in_bytes": 1639
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/find-uname.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b0e738fc9f62e479bf0974ab9cde0473fdf281c9d22fd0d3c8f42ec8cd549073",
+        "sha256_in_prefix": "b0e738fc9f62e479bf0974ab9cde0473fdf281c9d22fd0d3c8f42ec8cd549073",
+        "size_in_bytes": 1390
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/find_recursionlimit.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eb5d2fc36ae19dc30d954c36f477c0db184f067c668f4895a567751f2a499ec0",
+        "sha256_in_prefix": "eb5d2fc36ae19dc30d954c36f477c0db184f067c668f4895a567751f2a499ec0",
+        "size_in_bytes": 4908
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/finddiv.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "994cd7d1b094c6b426a8168f488ee88b6de10e74ac2e695a8f56b010fbf7851a",
+        "sha256_in_prefix": "994cd7d1b094c6b426a8168f488ee88b6de10e74ac2e695a8f56b010fbf7851a",
+        "size_in_bytes": 2583
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/findlinksto.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4160771d8e585337d02edecb5fe9534a9456aef064b07cd853aba3fddf72ab62",
+        "sha256_in_prefix": "4160771d8e585337d02edecb5fe9534a9456aef064b07cd853aba3fddf72ab62",
+        "size_in_bytes": 1103
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/findnocoding.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4ab978933b4733a514f0ab026b7d4cc2e1c718edd3e3e75603ee603767ddaeb6",
+        "sha256_in_prefix": "4ab978933b4733a514f0ab026b7d4cc2e1c718edd3e3e75603ee603767ddaeb6",
+        "size_in_bytes": 2606
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/fixcid.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ee9337f523c4b134026c3fe6d427b4439d441c1993be26b6ee21209fec6f0c7e",
+        "sha256_in_prefix": "ee9337f523c4b134026c3fe6d427b4439d441c1993be26b6ee21209fec6f0c7e",
+        "size_in_bytes": 6342
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/fixdiv.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6efab4dc8ccef649468ff5c83c671eb17e5db48f1d018509d7a7fb1df4e77e50",
+        "sha256_in_prefix": "6efab4dc8ccef649468ff5c83c671eb17e5db48f1d018509d7a7fb1df4e77e50",
+        "size_in_bytes": 12397
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/fixheader.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "81c877b472623b0f7ef681a1f28271d8a26621a24fd4655b82b59b47d9a20a1d",
+        "sha256_in_prefix": "81c877b472623b0f7ef681a1f28271d8a26621a24fd4655b82b59b47d9a20a1d",
+        "size_in_bytes": 1320
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/fixnotice.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "516d489c3fd32cdc5dfadb64b0fdd606bdde3f8cf5ee8b94711c861be7d51730",
+        "sha256_in_prefix": "516d489c3fd32cdc5dfadb64b0fdd606bdde3f8cf5ee8b94711c861be7d51730",
+        "size_in_bytes": 3070
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/fixps.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5a71b51611c0e75b560042fbd718654ba712827a5fd828b3e6fddf62dccc43e7",
+        "sha256_in_prefix": "5a71b51611c0e75b560042fbd718654ba712827a5fd828b3e6fddf62dccc43e7",
+        "size_in_bytes": 838
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/generate_opcode_h.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aef7a32457ec99078cf05d3b260dca8735d4351186671ac055f79c2bfde34847",
+        "sha256_in_prefix": "aef7a32457ec99078cf05d3b260dca8735d4351186671ac055f79c2bfde34847",
+        "size_in_bytes": 1487
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/generate_symbol_py.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ccf57b299ab3a0fd83bd80654faa8535537b1835365e7d5183c8b600992d1561",
+        "sha256_in_prefix": "ccf57b299ab3a0fd83bd80654faa8535537b1835365e7d5183c8b600992d1561",
+        "size_in_bytes": 1498
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/generate_token.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0316e62ca9aa8826eb6e7c338cd7086e1d3c95dc44efefa5e12b98d4b38e2fc7",
+        "sha256_in_prefix": "0316e62ca9aa8826eb6e7c338cd7086e1d3c95dc44efefa5e12b98d4b38e2fc7",
+        "size_in_bytes": 6163
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/get-remote-certificate.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "67024211913ff97fed86e70cdffe10fd2588621a878cc6ab7e89d119069d0984",
+        "sha256_in_prefix": "67024211913ff97fed86e70cdffe10fd2588621a878cc6ab7e89d119069d0984",
+        "size_in_bytes": 2082
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/google.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "15ffc4b7927620673504573f4905ae626456c46b12bbc1dd03b7321d3391cbe6",
+        "sha256_in_prefix": "15ffc4b7927620673504573f4905ae626456c46b12bbc1dd03b7321d3391cbe6",
+        "size_in_bytes": 883
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/gprof2html.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3071beec82a0736a55feb955770b7a729d837ecca1d34cc9369ac54decae0c43",
+        "sha256_in_prefix": "3071beec82a0736a55feb955770b7a729d837ecca1d34cc9369ac54decae0c43",
+        "size_in_bytes": 1978
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/highlight.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a209e7e15a3f219170cd8e3ae37a973ed013aeb9278800559c664e355eff81e6",
+        "sha256_in_prefix": "a209e7e15a3f219170cd8e3ae37a973ed013aeb9278800559c664e355eff81e6",
+        "size_in_bytes": 7727
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/ifdef.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1520c8325dc3d2313168b957dc986a1152a1c040ebfcefaaac0dfe9beadd628f",
+        "sha256_in_prefix": "1520c8325dc3d2313168b957dc986a1152a1c040ebfcefaaac0dfe9beadd628f",
+        "size_in_bytes": 1673
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/import_diagnostics.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "169ff27318f9a0660e006e283e6340dad618b996e3d6919aafb48442dc214be7",
+        "sha256_in_prefix": "169ff27318f9a0660e006e283e6340dad618b996e3d6919aafb48442dc214be7",
+        "size_in_bytes": 1330
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/lfcr.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "40477c1a90255182329916ab65ba96092cf35c9ec1c2d8a9dff303142221233d",
+        "sha256_in_prefix": "40477c1a90255182329916ab65ba96092cf35c9ec1c2d8a9dff303142221233d",
+        "size_in_bytes": 739
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/linktree.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "efbf8003d815cc9a02f4c27f14f3a9d60c4a1ee9c77c48b45ee2f28861bd0083",
+        "sha256_in_prefix": "efbf8003d815cc9a02f4c27f14f3a9d60c4a1ee9c77c48b45ee2f28861bd0083",
+        "size_in_bytes": 1687
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/lll.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7aa802b0a5727f4c5ac2d264f974951d2f825338272a8a7cc215c5e7b49fd812",
+        "sha256_in_prefix": "7aa802b0a5727f4c5ac2d264f974951d2f825338272a8a7cc215c5e7b49fd812",
+        "size_in_bytes": 702
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/mailerdaemon.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ee7e0afdb0776c4bcafa52a6754c307194ec3b3f9e183c418cd1e73dde77fc80",
+        "sha256_in_prefix": "ee7e0afdb0776c4bcafa52a6754c307194ec3b3f9e183c418cd1e73dde77fc80",
+        "size_in_bytes": 5845
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/make_ctype.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "da2f4a6efc837fd59e2e3f1801d346cdd8fb1027c1ddcd6d18a4986a0188baca",
+        "sha256_in_prefix": "da2f4a6efc837fd59e2e3f1801d346cdd8fb1027c1ddcd6d18a4986a0188baca",
+        "size_in_bytes": 2046
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/md5sum.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f29a965ceff80076a95f012710f2f325acbc96b7d718b434aeefacc9bd51ba9f",
+        "sha256_in_prefix": "f29a965ceff80076a95f012710f2f325acbc96b7d718b434aeefacc9bd51ba9f",
+        "size_in_bytes": 2456
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/mkreal.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9534d919292bca2e5fad7de020aa043e0a8eb7ae1e613b931e825b965a98b1f8",
+        "sha256_in_prefix": "9534d919292bca2e5fad7de020aa043e0a8eb7ae1e613b931e825b965a98b1f8",
+        "size_in_bytes": 1525
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/ndiff.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8a324303e4933c7c5045a7232141925d8eff856ad82188492507fe784cf7da28",
+        "sha256_in_prefix": "8a324303e4933c7c5045a7232141925d8eff856ad82188492507fe784cf7da28",
+        "size_in_bytes": 3232
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/nm2def.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eec68457f9fd647b95c993c90358bc1602e383eba49e6a73f3f7cdad59526420",
+        "sha256_in_prefix": "eec68457f9fd647b95c993c90358bc1602e383eba49e6a73f3f7cdad59526420",
+        "size_in_bytes": 2541
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/objgraph.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ea5e6841c559c00c213a5e750855fe6aa1ceb264a6861c10ec9e13c2d0d60485",
+        "sha256_in_prefix": "ea5e6841c559c00c213a5e750855fe6aa1ceb264a6861c10ec9e13c2d0d60485",
+        "size_in_bytes": 3911
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/parse_html5_entities.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5c834cd3008186688fbdaf6d1ddd85503d8416626f62e65bfc16f115c74a2323",
+        "sha256_in_prefix": "5c834cd3008186688fbdaf6d1ddd85503d8416626f62e65bfc16f115c74a2323",
+        "size_in_bytes": 2949
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/parseentities.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fa2f6a2321bfd8bd2ada8e28248681b2a0833a0336a853a756d9eb552176a975",
+        "sha256_in_prefix": "fa2f6a2321bfd8bd2ada8e28248681b2a0833a0336a853a756d9eb552176a975",
+        "size_in_bytes": 1695
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/patchcheck.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bb151467529ef8e1c6e5075f1166e56f7d85d36624ab204fcf5bc3579c6d024c",
+        "sha256_in_prefix": "bb151467529ef8e1c6e5075f1166e56f7d85d36624ab204fcf5bc3579c6d024c",
+        "size_in_bytes": 9963
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/pathfix.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f59ea027c96222e50dd7911def2bf7851bca3b95f8f36acbeb26739ac6f84e88",
+        "sha256_in_prefix": "f59ea027c96222e50dd7911def2bf7851bca3b95f8f36acbeb26739ac6f84e88",
+        "size_in_bytes": 4208
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/pdeps.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6f0626f5d3198a9002fbb741816055ded81f06164384042311a2853fc3098d4b",
+        "sha256_in_prefix": "6f0626f5d3198a9002fbb741816055ded81f06164384042311a2853fc3098d4b",
+        "size_in_bytes": 2468
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/pep384_macrocheck.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ab7694484b5d8a49e42f8e352e49fa3b646e22465190bf22ba385f70d2b5f753",
+        "sha256_in_prefix": "ab7694484b5d8a49e42f8e352e49fa3b646e22465190bf22ba385f70d2b5f753",
+        "size_in_bytes": 3624
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/pickle2db.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "46c3ae89ccfc1c9348877e5093557398057d656434ac1eedb4208bc016afd679",
+        "sha256_in_prefix": "46c3ae89ccfc1c9348877e5093557398057d656434ac1eedb4208bc016afd679",
+        "size_in_bytes": 3229
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/pindent.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9f4ec43cf35d5741a6c37f417c4c30dfc0a5fec6e30fe7b52d57f7c3d46fb60b",
+        "sha256_in_prefix": "9f4ec43cf35d5741a6c37f417c4c30dfc0a5fec6e30fe7b52d57f7c3d46fb60b",
+        "size_in_bytes": 8990
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/ptags.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0ec38951795544f2d5aad9413af1914951bc06bdf39c7541c0a68e10384972d6",
+        "sha256_in_prefix": "0ec38951795544f2d5aad9413af1914951bc06bdf39c7541c0a68e10384972d6",
+        "size_in_bytes": 1143
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/pydoc3.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b1f1435219edd0952bb402c91326c974ab00503817de4c5c114afeb5a2d5cf87",
+        "sha256_in_prefix": "b1f1435219edd0952bb402c91326c974ab00503817de4c5c114afeb5a2d5cf87",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/pysource.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7ee0d5c506164eb631d16ea7b4d19734d61cdac05ac51c2de3286441c587b5dc",
+        "sha256_in_prefix": "7ee0d5c506164eb631d16ea7b4d19734d61cdac05ac51c2de3286441c587b5dc",
+        "size_in_bytes": 3359
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/reindent-rst.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d7f6411d4abf210bbb89d1509c8487f48dfb08903691f8b6df8d013735704976",
+        "sha256_in_prefix": "d7f6411d4abf210bbb89d1509c8487f48dfb08903691f8b6df8d013735704976",
+        "size_in_bytes": 372
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/reindent.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aa435272ec145e4a700859eb0efb353c43c1afe4040fab09d0add10f15645fc7",
+        "sha256_in_prefix": "aa435272ec145e4a700859eb0efb353c43c1afe4040fab09d0add10f15645fc7",
+        "size_in_bytes": 8227
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/rgrep.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8102a6ba86c6517b296b66e6e03a51f38d84082116807d8b6757081f80515a51",
+        "sha256_in_prefix": "8102a6ba86c6517b296b66e6e03a51f38d84082116807d8b6757081f80515a51",
+        "size_in_bytes": 1501
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/run_tests.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7c5b849ac4f45358d3429312e634deccf7993b789b84896041bebee5e6e61093",
+        "sha256_in_prefix": "7c5b849ac4f45358d3429312e634deccf7993b789b84896041bebee5e6e61093",
+        "size_in_bytes": 1764
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/serve.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7a50e1d069e531b7e8aa8d28fa2498b1fb9ccfc173da87080ebed8f0e71233b6",
+        "sha256_in_prefix": "7a50e1d069e531b7e8aa8d28fa2498b1fb9ccfc173da87080ebed8f0e71233b6",
+        "size_in_bytes": 1359
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/smelly.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cdb4c9022c5759802ee34443c869ee4353e13e55f8c9f1cb17b50c5f5d85343b",
+        "sha256_in_prefix": "cdb4c9022c5759802ee34443c869ee4353e13e55f8c9f1cb17b50c5f5d85343b",
+        "size_in_bytes": 1691
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/suff.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a6fbe384e8fa2158aac6be5c394f5ddc81acd3b56ae9905d6fc9055b2efb29c5",
+        "sha256_in_prefix": "a6fbe384e8fa2158aac6be5c394f5ddc81acd3b56ae9905d6fc9055b2efb29c5",
+        "size_in_bytes": 648
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/texi2html.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9140ec830534bd0288c7e1f6beea374e775e7c1fb3552e4c0ea2a2053efa2d18",
+        "sha256_in_prefix": "9140ec830534bd0288c7e1f6beea374e775e7c1fb3552e4c0ea2a2053efa2d18",
+        "size_in_bytes": 68703
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/untabify.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "286c60fa1445862bf4bf6bd024f1b28436cde1527b07d0dc2e6ab85227dac731",
+        "sha256_in_prefix": "286c60fa1445862bf4bf6bd024f1b28436cde1527b07d0dc2e6ab85227dac731",
+        "size_in_bytes": 1395
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/update_file.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f4219cad4c9973643cd7960d44b97d5a90feacdac0334a23ec9eb7b2c165ab49",
+        "sha256_in_prefix": "f4219cad4c9973643cd7960d44b97d5a90feacdac0334a23ec9eb7b2c165ab49",
+        "size_in_bytes": 941
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/var_access_benchmark.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "708831d9c300a0209fc02deafb8af59b01a184eaca1e346ad6c649c2dab9c684",
+        "sha256_in_prefix": "708831d9c300a0209fc02deafb8af59b01a184eaca1e346ad6c649c2dab9c684",
+        "size_in_bytes": 10919
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/verify_ensurepip_wheels.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fdaf68555f7c2ee9c226e14d504af613d303f7e9ead6cbe05df05ae7f9875340",
+        "sha256_in_prefix": "fdaf68555f7c2ee9c226e14d504af613d303f7e9ead6cbe05df05ae7f9875340",
+        "size_in_bytes": 2781
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/which.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "207f36145c0d21397281f6bc860c394f4cb866238696ca52fab7e3a9ec7163e8",
+        "sha256_in_prefix": "207f36145c0d21397281f6bc860c394f4cb866238696ca52fab7e3a9ec7163e8",
+        "size_in_bytes": 1283
+      },
+      {
+        "_path": "Tools/scripts/__pycache__/win_add2path.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fc8c18171f23afe53c3f88d581adc629636ed6a5922dc447282c05088bd56337",
+        "sha256_in_prefix": "fc8c18171f23afe53c3f88d581adc629636ed6a5922dc447282c05088bd56337",
+        "size_in_bytes": 1708
+      },
+      {
+        "_path": "Tools/scripts/abitype.py",
+        "path_type": "hardlink",
+        "sha256": "e50b3874ab3d89544b9971a7e21c662acc6566f3fb14ad9e082829c6ad975a3f",
+        "sha256_in_prefix": "e50b3874ab3d89544b9971a7e21c662acc6566f3fb14ad9e082829c6ad975a3f",
+        "size_in_bytes": 5572
+      },
+      {
+        "_path": "Tools/scripts/analyze_dxp.py",
+        "path_type": "hardlink",
+        "sha256": "6b452cd913fe7bd8ab9eb6b00e2c3639161a0ec5337039d7effe50dee278a5da",
+        "sha256_in_prefix": "6b452cd913fe7bd8ab9eb6b00e2c3639161a0ec5337039d7effe50dee278a5da",
+        "size_in_bytes": 4183
+      },
+      {
+        "_path": "Tools/scripts/byext.py",
+        "path_type": "hardlink",
+        "sha256": "6ee9217c93e6f5585bf83a86d7e2fc798f0eac6234fd9a361e0391b44cca84da",
+        "sha256_in_prefix": "6ee9217c93e6f5585bf83a86d7e2fc798f0eac6234fd9a361e0391b44cca84da",
+        "size_in_bytes": 3904
+      },
+      {
+        "_path": "Tools/scripts/byteyears.py",
+        "path_type": "hardlink",
+        "sha256": "c5d951197c74d4d4717f186097a46771f337cd0337fbf68b8470cbc22b792a28",
+        "sha256_in_prefix": "c5d951197c74d4d4717f186097a46771f337cd0337fbf68b8470cbc22b792a28",
+        "size_in_bytes": 1650
+      },
+      {
+        "_path": "Tools/scripts/checkpip.py",
+        "path_type": "hardlink",
+        "sha256": "86383ad3550750bdaf6d84585a94797521b6819901adf2ede9f2b20bfbf0151d",
+        "sha256_in_prefix": "86383ad3550750bdaf6d84585a94797521b6819901adf2ede9f2b20bfbf0151d",
+        "size_in_bytes": 793
+      },
+      {
+        "_path": "Tools/scripts/cleanfuture.py",
+        "path_type": "hardlink",
+        "sha256": "bd2b01ca608607bb563f18475a562193a40c9a7e46d17f262f058da98f349313",
+        "sha256_in_prefix": "bd2b01ca608607bb563f18475a562193a40c9a7e46d17f262f058da98f349313",
+        "size_in_bytes": 8626
+      },
+      {
+        "_path": "Tools/scripts/combinerefs.py",
+        "path_type": "hardlink",
+        "sha256": "d5eaa708c29283b12ec7f86e1b9d020e6877fb73f90040e8ad5de06b31c8f6a2",
+        "sha256_in_prefix": "d5eaa708c29283b12ec7f86e1b9d020e6877fb73f90040e8ad5de06b31c8f6a2",
+        "size_in_bytes": 4454
+      },
+      {
+        "_path": "Tools/scripts/copytime.py",
+        "path_type": "hardlink",
+        "sha256": "d6ab4b778507420c244663df2fb2d5fe2ee5ee078d502a6da6026e1791eb34de",
+        "sha256_in_prefix": "d6ab4b778507420c244663df2fb2d5fe2ee5ee078d502a6da6026e1791eb34de",
+        "size_in_bytes": 663
+      },
+      {
+        "_path": "Tools/scripts/crlf.py",
+        "path_type": "hardlink",
+        "sha256": "188bb160b9b1262a4772e5d9dfc0374f5170e359c1867d3d7287967b58d2b2cb",
+        "sha256_in_prefix": "188bb160b9b1262a4772e5d9dfc0374f5170e359c1867d3d7287967b58d2b2cb",
+        "size_in_bytes": 632
+      },
+      {
+        "_path": "Tools/scripts/db2pickle.py",
+        "path_type": "hardlink",
+        "sha256": "004cf775fda2783974afc1599c33b77228f04f7c053760f4a9552927207a064e",
+        "sha256_in_prefix": "004cf775fda2783974afc1599c33b77228f04f7c053760f4a9552927207a064e",
+        "size_in_bytes": 3630
+      },
+      {
+        "_path": "Tools/scripts/diff.py",
+        "path_type": "hardlink",
+        "sha256": "103e18c5d4a0d24d3c0da99d1eaee3cbf11bb74430d10c4f7b0fef0ad3dc19c3",
+        "sha256_in_prefix": "103e18c5d4a0d24d3c0da99d1eaee3cbf11bb74430d10c4f7b0fef0ad3dc19c3",
+        "size_in_bytes": 2256
+      },
+      {
+        "_path": "Tools/scripts/dutree.py",
+        "path_type": "hardlink",
+        "sha256": "a7c4a2fe730e950a6fc9fab50b328f925585e005afe52e4fa524027f8bf990b5",
+        "sha256_in_prefix": "a7c4a2fe730e950a6fc9fab50b328f925585e005afe52e4fa524027f8bf990b5",
+        "size_in_bytes": 1638
+      },
+      {
+        "_path": "Tools/scripts/eptags.py",
+        "path_type": "hardlink",
+        "sha256": "54aa93343d6e6bd8b0f8d035eefe4aa28489b0579af2894a505e225c8290ef8f",
+        "sha256_in_prefix": "54aa93343d6e6bd8b0f8d035eefe4aa28489b0579af2894a505e225c8290ef8f",
+        "size_in_bytes": 1581
+      },
+      {
+        "_path": "Tools/scripts/find-uname.py",
+        "path_type": "hardlink",
+        "sha256": "332a86b31df9c0a0241963e9a127756cc2fbb73febcedb2c75225f16d9f7cbab",
+        "sha256_in_prefix": "332a86b31df9c0a0241963e9a127756cc2fbb73febcedb2c75225f16d9f7cbab",
+        "size_in_bytes": 1207
+      },
+      {
+        "_path": "Tools/scripts/find_recursionlimit.py",
+        "path_type": "hardlink",
+        "sha256": "4e4412d9176fa44b09de646ce52907f86c278dafab36f7f112a417ca1782f2f4",
+        "sha256_in_prefix": "4e4412d9176fa44b09de646ce52907f86c278dafab36f7f112a417ca1782f2f4",
+        "size_in_bytes": 3995
+      },
+      {
+        "_path": "Tools/scripts/finddiv.py",
+        "path_type": "hardlink",
+        "sha256": "17dad9fbca640261e2e4a749bd56391a5bb14d1a3a643b690a581f3bbd7374d6",
+        "sha256_in_prefix": "17dad9fbca640261e2e4a749bd56391a5bb14d1a3a643b690a581f3bbd7374d6",
+        "size_in_bytes": 2535
+      },
+      {
+        "_path": "Tools/scripts/findlinksto.py",
+        "path_type": "hardlink",
+        "sha256": "9511528eb787d474d5e38c8f73e9c0023f49805f104b2b588be5df65a88a519f",
+        "sha256_in_prefix": "9511528eb787d474d5e38c8f73e9c0023f49805f104b2b588be5df65a88a519f",
+        "size_in_bytes": 1071
+      },
+      {
+        "_path": "Tools/scripts/findnocoding.py",
+        "path_type": "hardlink",
+        "sha256": "0d829b2f82e65726a370c3b8afb75a193e58eeadba4e1f1f412107ff9102be4e",
+        "sha256_in_prefix": "0d829b2f82e65726a370c3b8afb75a193e58eeadba4e1f1f412107ff9102be4e",
+        "size_in_bytes": 2952
+      },
+      {
+        "_path": "Tools/scripts/fixcid.py",
+        "path_type": "hardlink",
+        "sha256": "99b58221231a292e056a135f76a6f0e3a0f146d8263b0072e2bb97d4d144b717",
+        "sha256_in_prefix": "99b58221231a292e056a135f76a6f0e3a0f146d8263b0072e2bb97d4d144b717",
+        "size_in_bytes": 10165
+      },
+      {
+        "_path": "Tools/scripts/fixdiv.py",
+        "path_type": "hardlink",
+        "sha256": "24caaf3cdc7fe677cfb8886a8fea7a0a878f7c96019fbca04ff4b92c934f64be",
+        "sha256_in_prefix": "24caaf3cdc7fe677cfb8886a8fea7a0a878f7c96019fbca04ff4b92c934f64be",
+        "size_in_bytes": 14241
+      },
+      {
+        "_path": "Tools/scripts/fixheader.py",
+        "path_type": "hardlink",
+        "sha256": "beaf5ca8ab28058fadb6a817a07dffe521eb60a032cb2e60719af3374da9819a",
+        "sha256_in_prefix": "beaf5ca8ab28058fadb6a817a07dffe521eb60a032cb2e60719af3374da9819a",
+        "size_in_bytes": 1359
+      },
+      {
+        "_path": "Tools/scripts/fixnotice.py",
+        "path_type": "hardlink",
+        "sha256": "61f827456acfa99c2dd97be8c59109b58bec738cbd11e126a1926f1419bf2100",
+        "sha256_in_prefix": "61f827456acfa99c2dd97be8c59109b58bec738cbd11e126a1926f1419bf2100",
+        "size_in_bytes": 3029
+      },
+      {
+        "_path": "Tools/scripts/fixps.py",
+        "path_type": "hardlink",
+        "sha256": "10bd8f27f521985a72a1b10d9122da00f89ed685bc079bebeeb5095b5463fc8e",
+        "sha256_in_prefix": "10bd8f27f521985a72a1b10d9122da00f89ed685bc079bebeeb5095b5463fc8e",
+        "size_in_bytes": 892
+      },
+      {
+        "_path": "Tools/scripts/generate_opcode_h.py",
+        "path_type": "hardlink",
+        "sha256": "3258661cee4c5ee764fb5273db0971228fcfa303c831aaec7486e76ab68f6177",
+        "sha256_in_prefix": "3258661cee4c5ee764fb5273db0971228fcfa303c831aaec7486e76ab68f6177",
+        "size_in_bytes": 1558
+      },
+      {
+        "_path": "Tools/scripts/generate_symbol_py.py",
+        "path_type": "hardlink",
+        "sha256": "e381137d2bfc6a8f08f4fa21b6d08ac0f70f979b49fb4cc6c645c48bb383363d",
+        "sha256_in_prefix": "e381137d2bfc6a8f08f4fa21b6d08ac0f70f979b49fb4cc6c645c48bb383363d",
+        "size_in_bytes": 1581
+      },
+      {
+        "_path": "Tools/scripts/generate_token.py",
+        "path_type": "hardlink",
+        "sha256": "30185edbeca159086761c95068c053aca0fd4ff0f3bc58d46c09437e49063510",
+        "sha256_in_prefix": "30185edbeca159086761c95068c053aca0fd4ff0f3bc58d46c09437e49063510",
+        "size_in_bytes": 6977
+      },
+      {
+        "_path": "Tools/scripts/get-remote-certificate.py",
+        "path_type": "hardlink",
+        "sha256": "8b8140346f970586094e630dae61aabae03b55cc3e447ddb4e39ff723d8c5f03",
+        "sha256_in_prefix": "8b8140346f970586094e630dae61aabae03b55cc3e447ddb4e39ff723d8c5f03",
+        "size_in_bytes": 2307
+      },
+      {
+        "_path": "Tools/scripts/google.py",
+        "path_type": "hardlink",
+        "sha256": "2866723cafa9519ea0f7292b6663bf84f3b933f6bf5b78184117efee85dd447d",
+        "sha256_in_prefix": "2866723cafa9519ea0f7292b6663bf84f3b933f6bf5b78184117efee85dd447d",
+        "size_in_bytes": 501
+      },
+      {
+        "_path": "Tools/scripts/gprof2html.py",
+        "path_type": "hardlink",
+        "sha256": "c619df68e6ae3535393aec13dbbc81dc7c88acdad79ce3ddc31709c8dd3e0bbb",
+        "sha256_in_prefix": "c619df68e6ae3535393aec13dbbc81dc7c88acdad79ce3ddc31709c8dd3e0bbb",
+        "size_in_bytes": 2303
+      },
+      {
+        "_path": "Tools/scripts/highlight.py",
+        "path_type": "hardlink",
+        "sha256": "fe757329d020804bf031ed7b7cc1d49d825ddbb715065dce58d33531d4de2bd2",
+        "sha256_in_prefix": "fe757329d020804bf031ed7b7cc1d49d825ddbb715065dce58d33531d4de2bd2",
+        "size_in_bytes": 9162
+      },
+      {
+        "_path": "Tools/scripts/ifdef.py",
+        "path_type": "hardlink",
+        "sha256": "496e621f9cee8f12894743fb767cfc5493442141f347990bc054878662ec22a5",
+        "sha256_in_prefix": "496e621f9cee8f12894743fb767cfc5493442141f347990bc054878662ec22a5",
+        "size_in_bytes": 3704
+      },
+      {
+        "_path": "Tools/scripts/import_diagnostics.py",
+        "path_type": "hardlink",
+        "sha256": "390a3d8d9c09f4ed63d5cba06a997448424176011b16d5e1b371f24b6bc465b6",
+        "sha256_in_prefix": "390a3d8d9c09f4ed63d5cba06a997448424176011b16d5e1b371f24b6bc465b6",
+        "size_in_bytes": 999
+      },
+      {
+        "_path": "Tools/scripts/lfcr.py",
+        "path_type": "hardlink",
+        "sha256": "62142195e8e5ab3a89606f27d41bd77b65abb59b463c446d6e577bfd55f47da3",
+        "sha256_in_prefix": "62142195e8e5ab3a89606f27d41bd77b65abb59b463c446d6e577bfd55f47da3",
+        "size_in_bytes": 640
+      },
+      {
+        "_path": "Tools/scripts/linktree.py",
+        "path_type": "hardlink",
+        "sha256": "496ec0a36a0c669808f70d3b411cae6b3806371d04cfa3435c9a96c7ef807c37",
+        "sha256_in_prefix": "496ec0a36a0c669808f70d3b411cae6b3806371d04cfa3435c9a96c7ef807c37",
+        "size_in_bytes": 2440
+      },
+      {
+        "_path": "Tools/scripts/lll.py",
+        "path_type": "hardlink",
+        "sha256": "7615e8b5f4b9a880c6431247daaccc984068cec6d896c9b2e950efb040571ef1",
+        "sha256_in_prefix": "7615e8b5f4b9a880c6431247daaccc984068cec6d896c9b2e950efb040571ef1",
+        "size_in_bytes": 748
+      },
+      {
+        "_path": "Tools/scripts/mailerdaemon.py",
+        "path_type": "hardlink",
+        "sha256": "65d82c2eb82783290c8ba1faaf4d01d203e2a5adefbccfdb8fc211dd84975ca5",
+        "sha256_in_prefix": "65d82c2eb82783290c8ba1faaf4d01d203e2a5adefbccfdb8fc211dd84975ca5",
+        "size_in_bytes": 8040
+      },
+      {
+        "_path": "Tools/scripts/make_ctype.py",
+        "path_type": "hardlink",
+        "sha256": "c450fefe8ccec1eb7bed7799ea750d2669a204024b336e0815fd2c7060225a94",
+        "sha256_in_prefix": "c450fefe8ccec1eb7bed7799ea750d2669a204024b336e0815fd2c7060225a94",
+        "size_in_bytes": 2280
+      },
+      {
+        "_path": "Tools/scripts/md5sum.py",
+        "path_type": "hardlink",
+        "sha256": "0071503614d8ab66fb51278f60573153fe8694e2de8bcf3f10ea955355368734",
+        "sha256_in_prefix": "0071503614d8ab66fb51278f60573153fe8694e2de8bcf3f10ea955355368734",
+        "size_in_bytes": 2518
+      },
+      {
+        "_path": "Tools/scripts/mkreal.py",
+        "path_type": "hardlink",
+        "sha256": "c45b34ba3e1b5d6c5f9b4eac79858a0bd89575056ed6c7f8e64716c7c7965df8",
+        "sha256_in_prefix": "c45b34ba3e1b5d6c5f9b4eac79858a0bd89575056ed6c7f8e64716c7c7965df8",
+        "size_in_bytes": 1631
+      },
+      {
+        "_path": "Tools/scripts/ndiff.py",
+        "path_type": "hardlink",
+        "sha256": "b6cdad1690b6c50a43b19239e119eb3fe5755453548b804268a3cdd83bbed7da",
+        "sha256_in_prefix": "b6cdad1690b6c50a43b19239e119eb3fe5755453548b804268a3cdd83bbed7da",
+        "size_in_bytes": 3820
+      },
+      {
+        "_path": "Tools/scripts/nm2def.py",
+        "path_type": "hardlink",
+        "sha256": "1674f9e4ca0f8d1253cdee2bd0ee491a7cd6899143d29249a7f1200fa59becb7",
+        "sha256_in_prefix": "1674f9e4ca0f8d1253cdee2bd0ee491a7cd6899143d29249a7f1200fa59becb7",
+        "size_in_bytes": 2483
+      },
+      {
+        "_path": "Tools/scripts/objgraph.py",
+        "path_type": "hardlink",
+        "sha256": "449b5fdd4d45d1568ab834e19eebca618baacf568f0c4ff4b8c8a7c5c0925939",
+        "sha256_in_prefix": "449b5fdd4d45d1568ab834e19eebca618baacf568f0c4ff4b8c8a7c5c0925939",
+        "size_in_bytes": 5942
+      },
+      {
+        "_path": "Tools/scripts/parse_html5_entities.py",
+        "path_type": "hardlink",
+        "sha256": "1d0d62cdc5aae0b6091f79cd942b64d6b00373e9a30b93da7f03c3fdc4647307",
+        "sha256_in_prefix": "1d0d62cdc5aae0b6091f79cd942b64d6b00373e9a30b93da7f03c3fdc4647307",
+        "size_in_bytes": 3999
+      },
+      {
+        "_path": "Tools/scripts/parseentities.py",
+        "path_type": "hardlink",
+        "sha256": "eb781e21cb5c8e66b433bff4471ee8cabc7a66f173b1b559455dddbdfdd6e22e",
+        "sha256_in_prefix": "eb781e21cb5c8e66b433bff4471ee8cabc7a66f173b1b559455dddbdfdd6e22e",
+        "size_in_bytes": 1740
+      },
+      {
+        "_path": "Tools/scripts/patchcheck.py",
+        "path_type": "hardlink",
+        "sha256": "21280eeee94bb6075df9b473109b9af6cd0900212b0fd37eebc5e7f44cb49b92",
+        "sha256_in_prefix": "21280eeee94bb6075df9b473109b9af6cd0900212b0fd37eebc5e7f44cb49b92",
+        "size_in_bytes": 10763
+      },
+      {
+        "_path": "Tools/scripts/pathfix.py",
+        "path_type": "hardlink",
+        "sha256": "7a2ff222346d3c95b08814e3372975823e099c17dddaa73a459a3d840e6e9c1b",
+        "sha256_in_prefix": "7a2ff222346d3c95b08814e3372975823e099c17dddaa73a459a3d840e6e9c1b",
+        "size_in_bytes": 6787
+      },
+      {
+        "_path": "Tools/scripts/pdeps.py",
+        "path_type": "hardlink",
+        "sha256": "e78b570d1d67083fe3fe4a6b1000b47c4b939a488a9e0bf21a1645f4149591dd",
+        "sha256_in_prefix": "e78b570d1d67083fe3fe4a6b1000b47c4b939a488a9e0bf21a1645f4149591dd",
+        "size_in_bytes": 3986
+      },
+      {
+        "_path": "Tools/scripts/pep384_macrocheck.py",
+        "path_type": "hardlink",
+        "sha256": "c0619417bc16fc80128048e8751c5261f2afd61f7a87fdc350a63936fcaf8d20",
+        "sha256_in_prefix": "c0619417bc16fc80128048e8751c5261f2afd61f7a87fdc350a63936fcaf8d20",
+        "size_in_bytes": 4719
+      },
+      {
+        "_path": "Tools/scripts/pickle2db.py",
+        "path_type": "hardlink",
+        "sha256": "e89c4eab0b199eb58ec21c2506eda27d46f838e1d0f84565b7cabfc8054fcb70",
+        "sha256_in_prefix": "e89c4eab0b199eb58ec21c2506eda27d46f838e1d0f84565b7cabfc8054fcb70",
+        "size_in_bytes": 4021
+      },
+      {
+        "_path": "Tools/scripts/pindent.py",
+        "path_type": "hardlink",
+        "sha256": "298ba6ff015bb3b43abd7012bf33e5a57786da99db45741d0687c4914a3b3664",
+        "sha256_in_prefix": "298ba6ff015bb3b43abd7012bf33e5a57786da99db45741d0687c4914a3b3664",
+        "size_in_bytes": 17127
+      },
+      {
+        "_path": "Tools/scripts/ptags.py",
+        "path_type": "hardlink",
+        "sha256": "ef7b450c4feb07bb8a4087c4d5824c05297a71fea72a1b4c265d83ffeb9475d6",
+        "sha256_in_prefix": "ef7b450c4feb07bb8a4087c4d5824c05297a71fea72a1b4c265d83ffeb9475d6",
+        "size_in_bytes": 1315
+      },
+      {
+        "_path": "Tools/scripts/pydoc3.py",
+        "path_type": "hardlink",
+        "sha256": "f03ae1cf496ad34a2cf82e33ff0a975878cccf769475015e95a7e0955d6e7063",
+        "sha256_in_prefix": "f03ae1cf496ad34a2cf82e33ff0a975878cccf769475015e95a7e0955d6e7063",
+        "size_in_bytes": 80
+      },
+      {
+        "_path": "Tools/scripts/pysource.py",
+        "path_type": "hardlink",
+        "sha256": "bdc639db52bab3683adf8748f902a4d30346eb12b8a085f92a6090ad6d71d564",
+        "sha256_in_prefix": "bdc639db52bab3683adf8748f902a4d30346eb12b8a085f92a6090ad6d71d564",
+        "size_in_bytes": 3864
+      },
+      {
+        "_path": "Tools/scripts/reindent-rst.py",
+        "path_type": "hardlink",
+        "sha256": "4d367080ae5c83b172071956bb4f0cea333d9506e8bc8a418844ae38959f9b33",
+        "sha256_in_prefix": "4d367080ae5c83b172071956bb4f0cea333d9506e8bc8a418844ae38959f9b33",
+        "size_in_bytes": 279
+      },
+      {
+        "_path": "Tools/scripts/reindent.py",
+        "path_type": "hardlink",
+        "sha256": "79afa4e2ef0cfca510d852a2a0e22ff15c0e5a0455a9d4f416f9761cd548c6d9",
+        "sha256_in_prefix": "79afa4e2ef0cfca510d852a2a0e22ff15c0e5a0455a9d4f416f9761cd548c6d9",
+        "size_in_bytes": 11647
+      },
+      {
+        "_path": "Tools/scripts/rgrep.py",
+        "path_type": "hardlink",
+        "sha256": "54e415c277df5a94b6fbc4c7400f0aa4213d830750f169b0999369a5c9b7608e",
+        "sha256_in_prefix": "54e415c277df5a94b6fbc4c7400f0aa4213d830750f169b0999369a5c9b7608e",
+        "size_in_bytes": 1580
+      },
+      {
+        "_path": "Tools/scripts/run_tests.py",
+        "path_type": "hardlink",
+        "sha256": "88a541699db8de726acf32506b62f7b84d24979f14f9bd3106fe39963ea67d97",
+        "sha256_in_prefix": "88a541699db8de726acf32506b62f7b84d24979f14f9bd3106fe39963ea67d97",
+        "size_in_bytes": 1866
+      },
+      {
+        "_path": "Tools/scripts/serve.py",
+        "path_type": "hardlink",
+        "sha256": "b8fc6f8a6d6e5c93b48be077a78944ef022d6b18b51448a2ace169504311b932",
+        "sha256_in_prefix": "b8fc6f8a6d6e5c93b48be077a78944ef022d6b18b51448a2ace169504311b932",
+        "size_in_bytes": 1224
+      },
+      {
+        "_path": "Tools/scripts/smelly.py",
+        "path_type": "hardlink",
+        "sha256": "17807976893255e07dc131bd9af0b194551b74e1a681ba6a5a1b351069dfdd9f",
+        "sha256_in_prefix": "17807976893255e07dc131bd9af0b194551b74e1a681ba6a5a1b351069dfdd9f",
+        "size_in_bytes": 2231
+      },
+      {
+        "_path": "Tools/scripts/suff.py",
+        "path_type": "hardlink",
+        "sha256": "7c9c5a591ee590d70caeadd38ad53675412a934fadc15f798529c42c7889cac0",
+        "sha256_in_prefix": "7c9c5a591ee590d70caeadd38ad53675412a934fadc15f798529c42c7889cac0",
+        "size_in_bytes": 510
+      },
+      {
+        "_path": "Tools/scripts/texi2html.py",
+        "path_type": "hardlink",
+        "sha256": "b7a3601b21a0c7d5b18302930762e5740a9e199e07075067df0381cf69501f81",
+        "sha256_in_prefix": "b7a3601b21a0c7d5b18302930762e5740a9e199e07075067df0381cf69501f81",
+        "size_in_bytes": 70373
+      },
+      {
+        "_path": "Tools/scripts/untabify.py",
+        "path_type": "hardlink",
+        "sha256": "a713c21b82c7118b85ed38c1e78840afac50d8c67d205bbeb2197170c5f750b5",
+        "sha256_in_prefix": "a713c21b82c7118b85ed38c1e78840afac50d8c67d205bbeb2197170c5f750b5",
+        "size_in_bytes": 1296
+      },
+      {
+        "_path": "Tools/scripts/update_file.py",
+        "path_type": "hardlink",
+        "sha256": "c6b86696411750e065a184dd8797ee1c2df567482c4cdd9107ed066b5a5feb9d",
+        "sha256_in_prefix": "c6b86696411750e065a184dd8797ee1c2df567482c4cdd9107ed066b5a5feb9d",
+        "size_in_bytes": 762
+      },
+      {
+        "_path": "Tools/scripts/var_access_benchmark.py",
+        "path_type": "hardlink",
+        "sha256": "ff0fd735a9a548cebce4380d9e1e7660f5f86a3d2ca3c240e4314a1231a27ea9",
+        "sha256_in_prefix": "ff0fd735a9a548cebce4380d9e1e7660f5f86a3d2ca3c240e4314a1231a27ea9",
+        "size_in_bytes": 11912
+      },
+      {
+        "_path": "Tools/scripts/verify_ensurepip_wheels.py",
+        "path_type": "hardlink",
+        "sha256": "e16936f8170020bdfb18e6b9e977f3f99fd250dc9e69aa79b25a7cea0b8ea749",
+        "sha256_in_prefix": "e16936f8170020bdfb18e6b9e977f3f99fd250dc9e69aa79b25a7cea0b8ea749",
+        "size_in_bytes": 3391
+      },
+      {
+        "_path": "Tools/scripts/which.py",
+        "path_type": "hardlink",
+        "sha256": "11b2b81ac4ee9076a0d9c0ccc789d047c9a1467f2763d12297f31b521a36cf28",
+        "sha256_in_prefix": "11b2b81ac4ee9076a0d9c0ccc789d047c9a1467f2763d12297f31b521a36cf28",
+        "size_in_bytes": 1686
+      },
+      {
+        "_path": "Tools/scripts/win_add2path.py",
+        "path_type": "hardlink",
+        "sha256": "30034ace8427493f3169bb46d870d6f0224eea86e0e1a3e85bc5faed1d398553",
+        "sha256_in_prefix": "30034ace8427493f3169bb46d870d6f0224eea86e0e1a3e85bc5faed1d398553",
+        "size_in_bytes": 1658
+      },
+      {
+        "_path": "include/Python-ast.h",
+        "path_type": "hardlink",
+        "sha256": "4769f41144a3ae305ef02aed7138272b25388109c8993116163485dde10fe183",
+        "sha256_in_prefix": "4769f41144a3ae305ef02aed7138272b25388109c8993116163485dde10fe183",
+        "size_in_bytes": 26193
+      },
+      {
+        "_path": "include/Python.h",
+        "path_type": "hardlink",
+        "sha256": "44751ae368c0c1b72c2c4a39b2d05cdb5f483cd16376a688fb190eab57509df8",
+        "sha256_in_prefix": "44751ae368c0c1b72c2c4a39b2d05cdb5f483cd16376a688fb190eab57509df8",
+        "size_in_bytes": 3532
+      },
+      {
+        "_path": "include/abstract.h",
+        "path_type": "hardlink",
+        "sha256": "d205b0c874b8bc0512378090301da3febbe9c07115b9fcd78e6f3ba07a64daa0",
+        "sha256_in_prefix": "d205b0c874b8bc0512378090301da3febbe9c07115b9fcd78e6f3ba07a64daa0",
+        "size_in_bytes": 30476
+      },
+      {
+        "_path": "include/asdl.h",
+        "path_type": "hardlink",
+        "sha256": "5ec93f0e325c084a055ff520e4c51df5e87172b4dd5dd297712f53062c4e1645",
+        "sha256_in_prefix": "5ec93f0e325c084a055ff520e4c51df5e87172b4dd5dd297712f53062c4e1645",
+        "size_in_bytes": 1224
+      },
+      {
+        "_path": "include/ast.h",
+        "path_type": "hardlink",
+        "sha256": "70490cda74a7e382e5b177a39b16256ec873ccef2bd202c663753e9d47aee7ff",
+        "sha256_in_prefix": "70490cda74a7e382e5b177a39b16256ec873ccef2bd202c663753e9d47aee7ff",
+        "size_in_bytes": 947
+      },
+      {
+        "_path": "include/bitset.h",
+        "path_type": "hardlink",
+        "sha256": "75c51a9bd20eb422824221fbc3e1b8a1216d635fbfc2a03e8ac608fbb4dc6340",
+        "sha256_in_prefix": "75c51a9bd20eb422824221fbc3e1b8a1216d635fbfc2a03e8ac608fbb4dc6340",
+        "size_in_bytes": 468
+      },
+      {
+        "_path": "include/bltinmodule.h",
+        "path_type": "hardlink",
+        "sha256": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72",
+        "sha256_in_prefix": "1b5101b4b85409fd910032713906800bbb83580503036469c2a60ac8e80b8f72",
+        "size_in_bytes": 264
+      },
+      {
+        "_path": "include/boolobject.h",
+        "path_type": "hardlink",
+        "sha256": "58618de27ab7ce3a8b52d6810ac929aa38a70deb370f89603613a273fd644367",
+        "sha256_in_prefix": "58618de27ab7ce3a8b52d6810ac929aa38a70deb370f89603613a273fd644367",
+        "size_in_bytes": 885
+      },
+      {
+        "_path": "include/bytearrayobject.h",
+        "path_type": "hardlink",
+        "sha256": "a6f332edc796f35283c9ea75bc59b525c82be52129cea32e3371974de08d6ee1",
+        "sha256_in_prefix": "a6f332edc796f35283c9ea75bc59b525c82be52129cea32e3371974de08d6ee1",
+        "size_in_bytes": 1484
+      },
+      {
+        "_path": "include/bytesobject.h",
+        "path_type": "hardlink",
+        "sha256": "fd5a0e17b61e246155e558bc4b06e2e5ee77ad7b75b0d27d00eafb182869bfcc",
+        "sha256_in_prefix": "fd5a0e17b61e246155e558bc4b06e2e5ee77ad7b75b0d27d00eafb182869bfcc",
+        "size_in_bytes": 3048
+      },
+      {
+        "_path": "include/cellobject.h",
+        "path_type": "hardlink",
+        "sha256": "2dbaf605207c6a67a772078d9e335a7a38c1260b28d36cfe1b15b6514dfb86d8",
+        "sha256_in_prefix": "2dbaf605207c6a67a772078d9e335a7a38c1260b28d36cfe1b15b6514dfb86d8",
+        "size_in_bytes": 712
+      },
+      {
+        "_path": "include/ceval.h",
+        "path_type": "hardlink",
+        "sha256": "885552517ba8a420fe54a75d7e98ca5066165475f97a9909a534ed8e2d99e715",
+        "sha256_in_prefix": "885552517ba8a420fe54a75d7e98ca5066165475f97a9909a534ed8e2d99e715",
+        "size_in_bytes": 5954
+      },
+      {
+        "_path": "include/classobject.h",
+        "path_type": "hardlink",
+        "sha256": "0a644a89790992499ad174d492c8d29778d95966498ee569ad8c6d90da54c054",
+        "sha256_in_prefix": "0a644a89790992499ad174d492c8d29778d95966498ee569ad8c6d90da54c054",
+        "size_in_bytes": 1657
+      },
+      {
+        "_path": "include/code.h",
+        "path_type": "hardlink",
+        "sha256": "de21eeb3ae7f1314e296727bd6db61cfe496e177a230ed75071e7af5b02d88b5",
+        "sha256_in_prefix": "de21eeb3ae7f1314e296727bd6db61cfe496e177a230ed75071e7af5b02d88b5",
+        "size_in_bytes": 318
+      },
+      {
+        "_path": "include/codecs.h",
+        "path_type": "hardlink",
+        "sha256": "d84f5b3738836973013339dc320c296355246169ebe5ebe2251516b4bb4357f1",
+        "sha256_in_prefix": "d84f5b3738836973013339dc320c296355246169ebe5ebe2251516b4bb4357f1",
+        "size_in_bytes": 6793
+      },
+      {
+        "_path": "include/compile.h",
+        "path_type": "hardlink",
+        "sha256": "00c2473525c922ea926cbe74eb6f4dc1f662cc2957db08deacd405eabfd09f41",
+        "sha256_in_prefix": "00c2473525c922ea926cbe74eb6f4dc1f662cc2957db08deacd405eabfd09f41",
+        "size_in_bytes": 3778
+      },
+      {
+        "_path": "include/complexobject.h",
+        "path_type": "hardlink",
+        "sha256": "7c224e629e3d2576ccbf045773863dcbef566f89b78d2a78e61418cae9c282cc",
+        "sha256_in_prefix": "7c224e629e3d2576ccbf045773863dcbef566f89b78d2a78e61418cae9c282cc",
+        "size_in_bytes": 1806
+      },
+      {
+        "_path": "include/context.h",
+        "path_type": "hardlink",
+        "sha256": "012ef77a9683a015e68728c4f43014921a04db0626c1dc9fbcc48a87d4e1012f",
+        "sha256_in_prefix": "012ef77a9683a015e68728c4f43014921a04db0626c1dc9fbcc48a87d4e1012f",
+        "size_in_bytes": 1962
+      },
+      {
+        "_path": "include/cpython/abstract.h",
+        "path_type": "hardlink",
+        "sha256": "66da03a2b649f9836530b6644a9878ce8dd60f65b3be2cde7a9aa13b2abc0dcf",
+        "sha256_in_prefix": "66da03a2b649f9836530b6644a9878ce8dd60f65b3be2cde7a9aa13b2abc0dcf",
+        "size_in_bytes": 14200
+      },
+      {
+        "_path": "include/cpython/bytearrayobject.h",
+        "path_type": "hardlink",
+        "sha256": "6c0ff5534ded2fb01ade071fad06e1561ea3ecb55970c4a79b86fd471fa9bd71",
+        "sha256_in_prefix": "6c0ff5534ded2fb01ade071fad06e1561ea3ecb55970c4a79b86fd471fa9bd71",
+        "size_in_bytes": 769
+      },
+      {
+        "_path": "include/cpython/bytesobject.h",
+        "path_type": "hardlink",
+        "sha256": "cc3c5f0f0799c6b850ac440f91daadb90fae62bd6d91481138959034a5c9b216",
+        "sha256_in_prefix": "cc3c5f0f0799c6b850ac440f91daadb90fae62bd6d91481138959034a5c9b216",
+        "size_in_bytes": 4114
+      },
+      {
+        "_path": "include/cpython/ceval.h",
+        "path_type": "hardlink",
+        "sha256": "56d3948e3084754c2838128abb15139a64a1beed2bac3483328d0e7131da973f",
+        "sha256_in_prefix": "56d3948e3084754c2838128abb15139a64a1beed2bac3483328d0e7131da973f",
+        "size_in_bytes": 1537
+      },
+      {
+        "_path": "include/cpython/code.h",
+        "path_type": "hardlink",
+        "sha256": "864152eebc1d01303462987c9c5e08b37562e95689603174b36de9b189e3e09e",
+        "sha256_in_prefix": "864152eebc1d01303462987c9c5e08b37562e95689603174b36de9b189e3e09e",
+        "size_in_bytes": 6989
+      },
+      {
+        "_path": "include/cpython/dictobject.h",
+        "path_type": "hardlink",
+        "sha256": "18e3622143795a494ecdcf087e170b3c5ad5d2d4859fcccf619042bdfd75222b",
+        "sha256_in_prefix": "18e3622143795a494ecdcf087e170b3c5ad5d2d4859fcccf619042bdfd75222b",
+        "size_in_bytes": 3797
+      },
+      {
+        "_path": "include/cpython/fileobject.h",
+        "path_type": "hardlink",
+        "sha256": "6be2bdf9226e734b931623ab481968d20b26616f385f7e4c33109b3e58e92851",
+        "sha256_in_prefix": "6be2bdf9226e734b931623ab481968d20b26616f385f7e4c33109b3e58e92851",
+        "size_in_bytes": 721
+      },
+      {
+        "_path": "include/cpython/fileutils.h",
+        "path_type": "hardlink",
+        "sha256": "3e33bc874767b7fbd8768926d1b81b84531f05be71fa6fdccd6657cb78b67361",
+        "sha256_in_prefix": "3e33bc874767b7fbd8768926d1b81b84531f05be71fa6fdccd6657cb78b67361",
+        "size_in_bytes": 4004
+      },
+      {
+        "_path": "include/cpython/frameobject.h",
+        "path_type": "hardlink",
+        "sha256": "46fad2bcd7be75617ebcab6ba223e09aa68e6572d3a6cc5f545ae188d0aa6501",
+        "sha256_in_prefix": "46fad2bcd7be75617ebcab6ba223e09aa68e6572d3a6cc5f545ae188d0aa6501",
+        "size_in_bytes": 3059
+      },
+      {
+        "_path": "include/cpython/import.h",
+        "path_type": "hardlink",
+        "sha256": "4ee65f882ed2fe7ad878a46294292cc5d002c02d77c45e914d0b251a0205c9e5",
+        "sha256_in_prefix": "4ee65f882ed2fe7ad878a46294292cc5d002c02d77c45e914d0b251a0205c9e5",
+        "size_in_bytes": 1473
+      },
+      {
+        "_path": "include/cpython/initconfig.h",
+        "path_type": "hardlink",
+        "sha256": "0ca06e552935733ada77d4da64cad7256a3bd5db35a7707ccb2cab5806884311",
+        "sha256_in_prefix": "0ca06e552935733ada77d4da64cad7256a3bd5db35a7707ccb2cab5806884311",
+        "size_in_bytes": 16979
+      },
+      {
+        "_path": "include/cpython/interpreteridobject.h",
+        "path_type": "hardlink",
+        "sha256": "c0890c2f0ac0e42eeeaacefb7e96d20b7efe43dacc542628e4c31057feba07e7",
+        "sha256_in_prefix": "c0890c2f0ac0e42eeeaacefb7e96d20b7efe43dacc542628e4c31057feba07e7",
+        "size_in_bytes": 456
+      },
+      {
+        "_path": "include/cpython/listobject.h",
+        "path_type": "hardlink",
+        "sha256": "66f9ccdf2cace04368eb7b02073bc0e42eae4bd0ab171a9946dfd8b4a28686ab",
+        "sha256_in_prefix": "66f9ccdf2cace04368eb7b02073bc0e42eae4bd0ab171a9946dfd8b4a28686ab",
+        "size_in_bytes": 1364
+      },
+      {
+        "_path": "include/cpython/methodobject.h",
+        "path_type": "hardlink",
+        "sha256": "d0356e04561a145b08aeb5c457d69443fd43875415844cba57aae3f5ec77c6be",
+        "sha256_in_prefix": "d0356e04561a145b08aeb5c457d69443fd43875415844cba57aae3f5ec77c6be",
+        "size_in_bytes": 1399
+      },
+      {
+        "_path": "include/cpython/object.h",
+        "path_type": "hardlink",
+        "sha256": "b18de1c98145e38809929e56d73956dceca1f0b6af59c8515b811d6a2ad5d57d",
+        "sha256_in_prefix": "b18de1c98145e38809929e56d73956dceca1f0b6af59c8515b811d6a2ad5d57d",
+        "size_in_bytes": 19358
+      },
+      {
+        "_path": "include/cpython/objimpl.h",
+        "path_type": "hardlink",
+        "sha256": "d7c8d2b9d513ec43f0c9d95a0a2203346a0279113e567994654594604b8296d4",
+        "sha256_in_prefix": "d7c8d2b9d513ec43f0c9d95a0a2203346a0279113e567994654594604b8296d4",
+        "size_in_bytes": 4456
+      },
+      {
+        "_path": "include/cpython/pyerrors.h",
+        "path_type": "hardlink",
+        "sha256": "c25d2d44ed35a3bedf45a8180ff6c721955cd34a7aceb11717e44b5980e0e8b6",
+        "sha256_in_prefix": "c25d2d44ed35a3bedf45a8180ff6c721955cd34a7aceb11717e44b5980e0e8b6",
+        "size_in_bytes": 5101
+      },
+      {
+        "_path": "include/cpython/pylifecycle.h",
+        "path_type": "hardlink",
+        "sha256": "a28b660e0581fb93423c397272078fe92a1efc8c811c8ff731becc7ae87cf61c",
+        "sha256_in_prefix": "a28b660e0581fb93423c397272078fe92a1efc8c811c8ff731becc7ae87cf61c",
+        "size_in_bytes": 2096
+      },
+      {
+        "_path": "include/cpython/pymem.h",
+        "path_type": "hardlink",
+        "sha256": "5886f079c359e44ffefc4d14698a26a64a54a6206da37f77c0f2e215962f5f05",
+        "sha256_in_prefix": "5886f079c359e44ffefc4d14698a26a64a54a6206da37f77c0f2e215962f5f05",
+        "size_in_bytes": 3511
+      },
+      {
+        "_path": "include/cpython/pystate.h",
+        "path_type": "hardlink",
+        "sha256": "13284abb7aa6b3f5188f3f43384bd230294a3ae0eb721af3c300d2007d4b5704",
+        "sha256_in_prefix": "13284abb7aa6b3f5188f3f43384bd230294a3ae0eb721af3c300d2007d4b5704",
+        "size_in_bytes": 10134
+      },
+      {
+        "_path": "include/cpython/sysmodule.h",
+        "path_type": "hardlink",
+        "sha256": "9431ba5d90cfd6d8d34efee8f358cd225953483a5f1b01094aa3b2714497753b",
+        "sha256_in_prefix": "9431ba5d90cfd6d8d34efee8f358cd225953483a5f1b01094aa3b2714497753b",
+        "size_in_bytes": 575
+      },
+      {
+        "_path": "include/cpython/traceback.h",
+        "path_type": "hardlink",
+        "sha256": "8f3eda3c6b0888728cf771aec2fa9877f9459b25b96763e8732c9ada77d1453b",
+        "sha256_in_prefix": "8f3eda3c6b0888728cf771aec2fa9877f9459b25b96763e8732c9ada77d1453b",
+        "size_in_bytes": 473
+      },
+      {
+        "_path": "include/cpython/tupleobject.h",
+        "path_type": "hardlink",
+        "sha256": "81d31d2a60d8c3293026f3e0ab2edacbdb13d4b1c03567db10431dd0ed89b320",
+        "sha256_in_prefix": "81d31d2a60d8c3293026f3e0ab2edacbdb13d4b1c03567db10431dd0ed89b320",
+        "size_in_bytes": 1036
+      },
+      {
+        "_path": "include/cpython/unicodeobject.h",
+        "path_type": "hardlink",
+        "sha256": "5c674ecc2e244616e0e955902589f98a9c71b85c0e4413101ceb5f563680b059",
+        "sha256_in_prefix": "5c674ecc2e244616e0e955902589f98a9c71b85c0e4413101ceb5f563680b059",
+        "size_in_bytes": 46736
+      },
+      {
+        "_path": "include/datetime.h",
+        "path_type": "hardlink",
+        "sha256": "e7b7f392226e4db637b5c71820f47abea098432b90e5c9674dce82e440cb73b4",
+        "sha256_in_prefix": "e7b7f392226e4db637b5c71820f47abea098432b90e5c9674dce82e440cb73b4",
+        "size_in_bytes": 9255
+      },
+      {
+        "_path": "include/descrobject.h",
+        "path_type": "hardlink",
+        "sha256": "984772dc5700cf157ea594abacf8bfe8a20a5287b2d98b1d29690dd401816717",
+        "sha256_in_prefix": "984772dc5700cf157ea594abacf8bfe8a20a5287b2d98b1d29690dd401816717",
+        "size_in_bytes": 3019
+      },
+      {
+        "_path": "include/dictobject.h",
+        "path_type": "hardlink",
+        "sha256": "7f998b9c48e026e7f34bdfca0fecaccc7c519b56e22f1691071aa7417011acbf",
+        "sha256_in_prefix": "7f998b9c48e026e7f34bdfca0fecaccc7c519b56e22f1691071aa7417011acbf",
+        "size_in_bytes": 3715
+      },
+      {
+        "_path": "include/dynamic_annotations.h",
+        "path_type": "hardlink",
+        "sha256": "73fe170efc01e7f2fcb4beb6060614619235be070494a106479987348515b6a7",
+        "sha256_in_prefix": "73fe170efc01e7f2fcb4beb6060614619235be070494a106479987348515b6a7",
+        "size_in_bytes": 22469
+      },
+      {
+        "_path": "include/enumobject.h",
+        "path_type": "hardlink",
+        "sha256": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6",
+        "sha256_in_prefix": "2244fe250db9995068fe74dce0e23fd70c12b03fd94751d98b773be8f64896b6",
+        "size_in_bytes": 253
+      },
+      {
+        "_path": "include/errcode.h",
+        "path_type": "hardlink",
+        "sha256": "bfa9472ea22fe0acdcc465625d8f2ed8e78e7f2c00891bc0e87bd4a7fd2454a4",
+        "sha256_in_prefix": "bfa9472ea22fe0acdcc465625d8f2ed8e78e7f2c00891bc0e87bd4a7fd2454a4",
+        "size_in_bytes": 1624
+      },
+      {
+        "_path": "include/eval.h",
+        "path_type": "hardlink",
+        "sha256": "a769f928d7a1721f7cf3b9c545de111a5b28333dae7745b67044dbf5e37c61d6",
+        "sha256_in_prefix": "a769f928d7a1721f7cf3b9c545de111a5b28333dae7745b67044dbf5e37c61d6",
+        "size_in_bytes": 1209
+      },
+      {
+        "_path": "include/exports.h",
+        "path_type": "hardlink",
+        "sha256": "f9242de8f731846164d4446745dd2a737ccdf83f754099018edc90485b1cd445",
+        "sha256_in_prefix": "f9242de8f731846164d4446745dd2a737ccdf83f754099018edc90485b1cd445",
+        "size_in_bytes": 1098
+      },
+      {
+        "_path": "include/fileobject.h",
+        "path_type": "hardlink",
+        "sha256": "4c89937726e6c30d62c361b48567a2de1c0533e7dc8ae8f805d9939842d00a7c",
+        "sha256_in_prefix": "4c89937726e6c30d62c361b48567a2de1c0533e7dc8ae8f805d9939842d00a7c",
+        "size_in_bytes": 1571
+      },
+      {
+        "_path": "include/fileutils.h",
+        "path_type": "hardlink",
+        "sha256": "10b199f2329273fcad50a4b87baf40a4f83fbb3c6a5014a04626dcbbe33cae0c",
+        "sha256_in_prefix": "10b199f2329273fcad50a4b87baf40a4f83fbb3c6a5014a04626dcbbe33cae0c",
+        "size_in_bytes": 597
+      },
+      {
+        "_path": "include/floatobject.h",
+        "path_type": "hardlink",
+        "sha256": "20bf507cf87f2b3574f1bd1ffd873e3fc6741cc0891b94fdbcf4237bd34b3f6b",
+        "sha256_in_prefix": "20bf507cf87f2b3574f1bd1ffd873e3fc6741cc0891b94fdbcf4237bd34b3f6b",
+        "size_in_bytes": 4360
+      },
+      {
+        "_path": "include/frameobject.h",
+        "path_type": "hardlink",
+        "sha256": "b69efe6636f05e79e50b5a1f46e3ed2602ac5d5eda9fb57a2d58d4cdc99edfb7",
+        "sha256_in_prefix": "b69efe6636f05e79e50b5a1f46e3ed2602ac5d5eda9fb57a2d58d4cdc99edfb7",
+        "size_in_bytes": 337
+      },
+      {
+        "_path": "include/funcobject.h",
+        "path_type": "hardlink",
+        "sha256": "5ba01bcff6f9c50281ae15605bafdf6fe2be8c1297c5f58380409021faf68778",
+        "sha256_in_prefix": "5ba01bcff6f9c50281ae15605bafdf6fe2be8c1297c5f58380409021faf68778",
+        "size_in_bytes": 4057
+      },
+      {
+        "_path": "include/genericaliasobject.h",
+        "path_type": "hardlink",
+        "sha256": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8",
+        "sha256_in_prefix": "0e53a0b18c114be68eccea9ffd1dd577e204b1f0ada4d3aedc8e7ee0c80fc7f8",
+        "size_in_bytes": 334
+      },
+      {
+        "_path": "include/genobject.h",
+        "path_type": "hardlink",
+        "sha256": "5d2b0a27ee60246a5130b6258350da0e50745005b2a17b15a55dd08bff5bcefe",
+        "sha256_in_prefix": "5d2b0a27ee60246a5130b6258350da0e50745005b2a17b15a55dd08bff5bcefe",
+        "size_in_bytes": 3525
+      },
+      {
+        "_path": "include/graminit.h",
+        "path_type": "hardlink",
+        "sha256": "9ad2d4aafe85a72337ee8d783607faa9411aed09995da6ea2b9a5abd7b67c255",
+        "sha256_in_prefix": "9ad2d4aafe85a72337ee8d783607faa9411aed09995da6ea2b9a5abd7b67c255",
+        "size_in_bytes": 2118
+      },
+      {
+        "_path": "include/grammar.h",
+        "path_type": "hardlink",
+        "sha256": "229730c2fb8fd418fe61bca568d39e014309a9c57ef5118dc413a127995a7548",
+        "sha256_in_prefix": "229730c2fb8fd418fe61bca568d39e014309a9c57ef5118dc413a127995a7548",
+        "size_in_bytes": 1821
+      },
+      {
+        "_path": "include/import.h",
+        "path_type": "hardlink",
+        "sha256": "f32a4d416cf558d49d797f8d67d9078917258ed5af1daa734755c8be2c8c76b2",
+        "sha256_in_prefix": "f32a4d416cf558d49d797f8d67d9078917258ed5af1daa734755c8be2c8c76b2",
+        "size_in_bytes": 3026
+      },
+      {
+        "_path": "include/internal/pegen_interface.h",
+        "path_type": "hardlink",
+        "sha256": "95a32d521bb2122ea54c1c9c21099368d7118272ccf17a01667f216d6701a891",
+        "sha256_in_prefix": "95a32d521bb2122ea54c1c9c21099368d7118272ccf17a01667f216d6701a891",
+        "size_in_bytes": 953
+      },
+      {
+        "_path": "include/internal/pycore_abstract.h",
+        "path_type": "hardlink",
+        "sha256": "ac474dbc0e522a5b59cff25c50f02eb75b08bf60b9056d84bdfd06d7202e9af3",
+        "sha256_in_prefix": "ac474dbc0e522a5b59cff25c50f02eb75b08bf60b9056d84bdfd06d7202e9af3",
+        "size_in_bytes": 479
+      },
+      {
+        "_path": "include/internal/pycore_accu.h",
+        "path_type": "hardlink",
+        "sha256": "0af5cf048f515646d68566bd8786e973c45a501f23782d80961e390b116adb2b",
+        "sha256_in_prefix": "0af5cf048f515646d68566bd8786e973c45a501f23782d80961e390b116adb2b",
+        "size_in_bytes": 1126
+      },
+      {
+        "_path": "include/internal/pycore_atomic.h",
+        "path_type": "hardlink",
+        "sha256": "07156dd6debd9f9b0d14fdba156e692e3f13658e1150baabc76172a6532edf71",
+        "sha256_in_prefix": "07156dd6debd9f9b0d14fdba156e692e3f13658e1150baabc76172a6532edf71",
+        "size_in_bytes": 16977
+      },
+      {
+        "_path": "include/internal/pycore_bytes_methods.h",
+        "path_type": "hardlink",
+        "sha256": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00",
+        "sha256_in_prefix": "1534326dbf027e9bb472be5ccf8b82fab48f3282cc7f6a61629b801fc80afc00",
+        "size_in_bytes": 3384
+      },
+      {
+        "_path": "include/internal/pycore_byteswap.h",
+        "path_type": "hardlink",
+        "sha256": "5b1fb4b7a9e040cfa2dd0249ce7b5bc87a225aea4cbfc4797aed44ce5229256a",
+        "sha256_in_prefix": "5b1fb4b7a9e040cfa2dd0249ce7b5bc87a225aea4cbfc4797aed44ce5229256a",
+        "size_in_bytes": 2620
+      },
+      {
+        "_path": "include/internal/pycore_call.h",
+        "path_type": "hardlink",
+        "sha256": "99ca19ee267b138ed3412505413d3c252cda8b049c42cc7f6f7395d2b438bae6",
+        "sha256_in_prefix": "99ca19ee267b138ed3412505413d3c252cda8b049c42cc7f6f7395d2b438bae6",
+        "size_in_bytes": 870
+      },
+      {
+        "_path": "include/internal/pycore_ceval.h",
+        "path_type": "hardlink",
+        "sha256": "e703836c9546da1992b7b0a96e6ba63ff24b6d0799ec9fd9d54ee6dbbc472a6a",
+        "sha256_in_prefix": "e703836c9546da1992b7b0a96e6ba63ff24b6d0799ec9fd9d54ee6dbbc472a6a",
+        "size_in_bytes": 3403
+      },
+      {
+        "_path": "include/internal/pycore_code.h",
+        "path_type": "hardlink",
+        "sha256": "0257b9411b31be2dcdc728ac39b2558518584d6d50e98683557246635fd5da2a",
+        "sha256_in_prefix": "0257b9411b31be2dcdc728ac39b2558518584d6d50e98683557246635fd5da2a",
+        "size_in_bytes": 541
+      },
+      {
+        "_path": "include/internal/pycore_condvar.h",
+        "path_type": "hardlink",
+        "sha256": "3d37e1739052022a8d120096ffc8521e29a4a930c339a70e315dade3fadd62f5",
+        "sha256_in_prefix": "3d37e1739052022a8d120096ffc8521e29a4a930c339a70e315dade3fadd62f5",
+        "size_in_bytes": 2809
+      },
+      {
+        "_path": "include/internal/pycore_context.h",
+        "path_type": "hardlink",
+        "sha256": "91b849355564b14e790cbf3a74dba30083de621dad3125f5239f98d9d8f706e7",
+        "sha256_in_prefix": "91b849355564b14e790cbf3a74dba30083de621dad3125f5239f98d9d8f706e7",
+        "size_in_bytes": 800
+      },
+      {
+        "_path": "include/internal/pycore_dtoa.h",
+        "path_type": "hardlink",
+        "sha256": "fb94584844dc81a7f8093119cc8119790d31c57c53e7ba462d6c9e47ccde6d86",
+        "sha256_in_prefix": "fb94584844dc81a7f8093119cc8119790d31c57c53e7ba462d6c9e47ccde6d86",
+        "size_in_bytes": 646
+      },
+      {
+        "_path": "include/internal/pycore_fileutils.h",
+        "path_type": "hardlink",
+        "sha256": "1cd66828c9f50d3df8cfcbe02178ba56f3d273fe34dda48ebeb965c16b6cb3ba",
+        "sha256_in_prefix": "1cd66828c9f50d3df8cfcbe02178ba56f3d273fe34dda48ebeb965c16b6cb3ba",
+        "size_in_bytes": 1541
+      },
+      {
+        "_path": "include/internal/pycore_gc.h",
+        "path_type": "hardlink",
+        "sha256": "d417b72080dcd2f61d27f1dc2af19d4ecd0b2b77908df6dd39758695be0b4999",
+        "sha256_in_prefix": "d417b72080dcd2f61d27f1dc2af19d4ecd0b2b77908df6dd39758695be0b4999",
+        "size_in_bytes": 6647
+      },
+      {
+        "_path": "include/internal/pycore_getopt.h",
+        "path_type": "hardlink",
+        "sha256": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452",
+        "sha256_in_prefix": "e93393067b66b557b0300e05c10ee904d4be54cadfb214c5328a9225ad199452",
+        "size_in_bytes": 490
+      },
+      {
+        "_path": "include/internal/pycore_gil.h",
+        "path_type": "hardlink",
+        "sha256": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b",
+        "sha256_in_prefix": "cf455aacd5651e5b43547ebe69bb324eab84238d92665df53c1df32434bd0d9b",
+        "size_in_bytes": 1565
+      },
+      {
+        "_path": "include/internal/pycore_hamt.h",
+        "path_type": "hardlink",
+        "sha256": "a5650972b76b05a4319421a5122493310f0a63bdcee7a068a0c57f79abdd55f4",
+        "sha256_in_prefix": "a5650972b76b05a4319421a5122493310f0a63bdcee7a068a0c57f79abdd55f4",
+        "size_in_bytes": 3697
+      },
+      {
+        "_path": "include/internal/pycore_hashtable.h",
+        "path_type": "hardlink",
+        "sha256": "75e903486d6b6e0468770a6bc3895d8b9423c1b64614e38b29a1d65a1d5bfdf7",
+        "sha256_in_prefix": "75e903486d6b6e0468770a6bc3895d8b9423c1b64614e38b29a1d65a1d5bfdf7",
+        "size_in_bytes": 4197
+      },
+      {
+        "_path": "include/internal/pycore_import.h",
+        "path_type": "hardlink",
+        "sha256": "a00468bcfdf95deb10ca3fd2304465b2d171eacfb8964cacc5f1f4b2ad216682",
+        "sha256_in_prefix": "a00468bcfdf95deb10ca3fd2304465b2d171eacfb8964cacc5f1f4b2ad216682",
+        "size_in_bytes": 473
+      },
+      {
+        "_path": "include/internal/pycore_initconfig.h",
+        "path_type": "hardlink",
+        "sha256": "df4ca8fbc627c7c155e3e9fc5affcd942ac094025e0e5ac827611bdb46b3b89b",
+        "sha256_in_prefix": "df4ca8fbc627c7c155e3e9fc5affcd942ac094025e0e5ac827611bdb46b3b89b",
+        "size_in_bytes": 5233
+      },
+      {
+        "_path": "include/internal/pycore_interp.h",
+        "path_type": "hardlink",
+        "sha256": "7980a52a6243e761c00165d0495cfa24c0f9a57ac2b164c8a7bfb8e73071ba78",
+        "sha256_in_prefix": "7980a52a6243e761c00165d0495cfa24c0f9a57ac2b164c8a7bfb8e73071ba78",
+        "size_in_bytes": 5299
+      },
+      {
+        "_path": "include/internal/pycore_long.h",
+        "path_type": "hardlink",
+        "sha256": "a23039e046c603bf9b624f2ce85bbb450c0a9256f615a1704b209ada133a0887",
+        "sha256_in_prefix": "a23039e046c603bf9b624f2ce85bbb450c0a9256f615a1704b209ada133a0887",
+        "size_in_bytes": 1548
+      },
+      {
+        "_path": "include/internal/pycore_object.h",
+        "path_type": "hardlink",
+        "sha256": "878bc8d04b7de82ceb5eaf450083579c49eefa3c86525f47dda185f619232eba",
+        "sha256_in_prefix": "878bc8d04b7de82ceb5eaf450083579c49eefa3c86525f47dda185f619232eba",
+        "size_in_bytes": 4157
+      },
+      {
+        "_path": "include/internal/pycore_pathconfig.h",
+        "path_type": "hardlink",
+        "sha256": "e3ae9e349b82887f0ddf8443d3773d3926b0bbccbd65ddd3521c36afa690a205",
+        "sha256_in_prefix": "e3ae9e349b82887f0ddf8443d3773d3926b0bbccbd65ddd3521c36afa690a205",
+        "size_in_bytes": 1936
+      },
+      {
+        "_path": "include/internal/pycore_pyerrors.h",
+        "path_type": "hardlink",
+        "sha256": "8d98300735e9c2aa1bc50378beed2c6ae92a10443a7483f746ce5dcca8252c24",
+        "sha256_in_prefix": "8d98300735e9c2aa1bc50378beed2c6ae92a10443a7483f746ce5dcca8252c24",
+        "size_in_bytes": 2032
+      },
+      {
+        "_path": "include/internal/pycore_pyhash.h",
+        "path_type": "hardlink",
+        "sha256": "6e9db9d3e7d7245b10e33598b995fc9b51b3952ce17225830d0248c6fa62dd51",
+        "sha256_in_prefix": "6e9db9d3e7d7245b10e33598b995fc9b51b3952ce17225830d0248c6fa62dd51",
+        "size_in_bytes": 206
+      },
+      {
+        "_path": "include/internal/pycore_pylifecycle.h",
+        "path_type": "hardlink",
+        "sha256": "fd97360d873a699344afa12ae93fe8505fdf4f5058b87a90886af1f1cddf4468",
+        "sha256_in_prefix": "fd97360d873a699344afa12ae93fe8505fdf4f5058b87a90886af1f1cddf4468",
+        "size_in_bytes": 3741
+      },
+      {
+        "_path": "include/internal/pycore_pymem.h",
+        "path_type": "hardlink",
+        "sha256": "be54199c8df89d0f2d793c853a1680d0549d452495ca33cf9006251ad659b82f",
+        "sha256_in_prefix": "be54199c8df89d0f2d793c853a1680d0549d452495ca33cf9006251ad659b82f",
+        "size_in_bytes": 3363
+      },
+      {
+        "_path": "include/internal/pycore_pystate.h",
+        "path_type": "hardlink",
+        "sha256": "cde86a206501300edf616a0effafb90a414829041a54d6150d8590140f6b11f8",
+        "sha256_in_prefix": "cde86a206501300edf616a0effafb90a414829041a54d6150d8590140f6b11f8",
+        "size_in_bytes": 3583
+      },
+      {
+        "_path": "include/internal/pycore_runtime.h",
+        "path_type": "hardlink",
+        "sha256": "fd5683de36f34f1e1e8db9d377aecce041949a7afe2e5ff0af5c6a4a6bdb69df",
+        "sha256_in_prefix": "fd5683de36f34f1e1e8db9d377aecce041949a7afe2e5ff0af5c6a4a6bdb69df",
+        "size_in_bytes": 4452
+      },
+      {
+        "_path": "include/internal/pycore_sysmodule.h",
+        "path_type": "hardlink",
+        "sha256": "091730828d6b60293756f9ed5f700bb77e7f2419f6b05c9fc0f2e02708617fb5",
+        "sha256_in_prefix": "091730828d6b60293756f9ed5f700bb77e7f2419f6b05c9fc0f2e02708617fb5",
+        "size_in_bytes": 548
+      },
+      {
+        "_path": "include/internal/pycore_traceback.h",
+        "path_type": "hardlink",
+        "sha256": "ba22732ad4f144710e578d72b27ba4e4920cc9c8457954616b27f15121220c57",
+        "sha256_in_prefix": "ba22732ad4f144710e578d72b27ba4e4920cc9c8457954616b27f15121220c57",
+        "size_in_bytes": 3056
+      },
+      {
+        "_path": "include/internal/pycore_tupleobject.h",
+        "path_type": "hardlink",
+        "sha256": "3a827fab4153943669752f59d17b0b3758a4a47b542a4b5eaed538130b9e8a50",
+        "sha256_in_prefix": "3a827fab4153943669752f59d17b0b3758a4a47b542a4b5eaed538130b9e8a50",
+        "size_in_bytes": 442
+      },
+      {
+        "_path": "include/internal/pycore_warnings.h",
+        "path_type": "hardlink",
+        "sha256": "4fd87f2a5d5b2944c99f85dff5682433b7c4d0a355c25e5c7274e46a253feda1",
+        "sha256_in_prefix": "4fd87f2a5d5b2944c99f85dff5682433b7c4d0a355c25e5c7274e46a253feda1",
+        "size_in_bytes": 633
+      },
+      {
+        "_path": "include/interpreteridobject.h",
+        "path_type": "hardlink",
+        "sha256": "62d060794f7488f365402db81ded3d588b6d7759eb0de9194329fd01a9374cf6",
+        "sha256_in_prefix": "62d060794f7488f365402db81ded3d588b6d7759eb0de9194329fd01a9374cf6",
+        "size_in_bytes": 334
+      },
+      {
+        "_path": "include/intrcheck.h",
+        "path_type": "hardlink",
+        "sha256": "63920ab66fb23e7dd00fcd360f094e93d0fb029c82c56e6b5538552b401b0459",
+        "sha256_in_prefix": "63920ab66fb23e7dd00fcd360f094e93d0fb029c82c56e6b5538552b401b0459",
+        "size_in_bytes": 861
+      },
+      {
+        "_path": "include/iterobject.h",
+        "path_type": "hardlink",
+        "sha256": "14ddefb8137e33495788609782583c52338dd729a37a269bbf44a38a39ead1ae",
+        "sha256_in_prefix": "14ddefb8137e33495788609782583c52338dd729a37a269bbf44a38a39ead1ae",
+        "size_in_bytes": 521
+      },
+      {
+        "_path": "include/listobject.h",
+        "path_type": "hardlink",
+        "sha256": "fea25ac3a5d8f0b8678cd77eba73cf9c3797490a24c1e6585bf255982ab48c23",
+        "sha256_in_prefix": "fea25ac3a5d8f0b8678cd77eba73cf9c3797490a24c1e6585bf255982ab48c23",
+        "size_in_bytes": 1781
+      },
+      {
+        "_path": "include/longintrepr.h",
+        "path_type": "hardlink",
+        "sha256": "28dddc9f2d5db3e383d1e921a7731bdff683ec394b8fd334f6cba14241d5d244",
+        "sha256_in_prefix": "28dddc9f2d5db3e383d1e921a7731bdff683ec394b8fd334f6cba14241d5d244",
+        "size_in_bytes": 3799
+      },
+      {
+        "_path": "include/longobject.h",
+        "path_type": "hardlink",
+        "sha256": "846153968555e33247ee678fbfbfb1373ca0c089a6020f007ba30b2ac9072d2e",
+        "sha256_in_prefix": "846153968555e33247ee678fbfbfb1373ca0c089a6020f007ba30b2ac9072d2e",
+        "size_in_bytes": 9513
+      },
+      {
+        "_path": "include/marshal.h",
+        "path_type": "hardlink",
+        "sha256": "06ba6a68154f85951794529465a07e07444fb852440059a398c98344004a27f5",
+        "sha256_in_prefix": "06ba6a68154f85951794529465a07e07444fb852440059a398c98344004a27f5",
+        "size_in_bytes": 803
+      },
+      {
+        "_path": "include/memoryobject.h",
+        "path_type": "hardlink",
+        "sha256": "5a89491cd879fd90ba20525c710c74e278d2432da789ce6c608ee4c65920cd48",
+        "sha256_in_prefix": "5a89491cd879fd90ba20525c710c74e278d2432da789ce6c608ee4c65920cd48",
+        "size_in_bytes": 2764
+      },
+      {
+        "_path": "include/methodobject.h",
+        "path_type": "hardlink",
+        "sha256": "40785419c9fe0196ed69e39bb476306d53033892bb0a2a07096b348400908192",
+        "sha256_in_prefix": "40785419c9fe0196ed69e39bb476306d53033892bb0a2a07096b348400908192",
+        "size_in_bytes": 3775
+      },
+      {
+        "_path": "include/modsupport.h",
+        "path_type": "hardlink",
+        "sha256": "1ee6a7326d5674b9b512ef47a0796192a8ef1f67e35d062c09e1fc20878a0426",
+        "sha256_in_prefix": "1ee6a7326d5674b9b512ef47a0796192a8ef1f67e35d062c09e1fc20878a0426",
+        "size_in_bytes": 9959
+      },
+      {
+        "_path": "include/moduleobject.h",
+        "path_type": "hardlink",
+        "sha256": "11f23f3ced05a7a34a1c00506f3d506a0029ebf4e6b143b0c8812d45d13be8f1",
+        "sha256_in_prefix": "11f23f3ced05a7a34a1c00506f3d506a0029ebf4e6b143b0c8812d45d13be8f1",
+        "size_in_bytes": 2361
+      },
+      {
+        "_path": "include/namespaceobject.h",
+        "path_type": "hardlink",
+        "sha256": "d282d6d0c6493f56921c039bfa23fd38bc4a643ebb9ace07108d9b170900fbc8",
+        "sha256_in_prefix": "d282d6d0c6493f56921c039bfa23fd38bc4a643ebb9ace07108d9b170900fbc8",
+        "size_in_bytes": 349
+      },
+      {
+        "_path": "include/node.h",
+        "path_type": "hardlink",
+        "sha256": "407d6c7095bce14b2b389f955ef479751f54f724db6d60fc4d228dffff53c194",
+        "sha256_in_prefix": "407d6c7095bce14b2b389f955ef479751f54f724db6d60fc4d228dffff53c194",
+        "size_in_bytes": 1281
+      },
+      {
+        "_path": "include/object.h",
+        "path_type": "hardlink",
+        "sha256": "bbdaefd404779575bb4eee681495aced6be4ece35d7af4ef66ea651e9073a011",
+        "sha256_in_prefix": "bbdaefd404779575bb4eee681495aced6be4ece35d7af4ef66ea651e9073a011",
+        "size_in_bytes": 24628
+      },
+      {
+        "_path": "include/objimpl.h",
+        "path_type": "hardlink",
+        "sha256": "9813aa3e546ca25d5388c15d7bbb5df735366d16f3ffd050bade944d1184d5ff",
+        "sha256_in_prefix": "9813aa3e546ca25d5388c15d7bbb5df735366d16f3ffd050bade944d1184d5ff",
+        "size_in_bytes": 8423
+      },
+      {
+        "_path": "include/odictobject.h",
+        "path_type": "hardlink",
+        "sha256": "ff2b0d77aea871c1edd6f63209489fe70c7c11d4da9c3e2f6ef6858cdb004a0d",
+        "sha256_in_prefix": "ff2b0d77aea871c1edd6f63209489fe70c7c11d4da9c3e2f6ef6858cdb004a0d",
+        "size_in_bytes": 1299
+      },
+      {
+        "_path": "include/opcode.h",
+        "path_type": "hardlink",
+        "sha256": "52b53c1b24fc4239b0d76aab131fb3bd4e2b9e9014d719bbac41cc1a3dcec03c",
+        "sha256_in_prefix": "52b53c1b24fc4239b0d76aab131fb3bd4e2b9e9014d719bbac41cc1a3dcec03c",
+        "size_in_bytes": 4900
+      },
+      {
+        "_path": "include/osdefs.h",
+        "path_type": "hardlink",
+        "sha256": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c",
+        "sha256_in_prefix": "8372e9c507949a88ed3cad5fd0a830190d60a1655e9a3f59ef4d0832c06a041c",
+        "size_in_bytes": 737
+      },
+      {
+        "_path": "include/osmodule.h",
+        "path_type": "hardlink",
+        "sha256": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9",
+        "sha256_in_prefix": "c013935b48f48ca8ce249a4d482c55e3fb6f1cfe786c5a32a57969bb74a779d9",
+        "size_in_bytes": 291
+      },
+      {
+        "_path": "include/parsetok.h",
+        "path_type": "hardlink",
+        "sha256": "bc38ccb23eae0e0e54cc9f45945c3c46d0907a856ea0c02e4c1311a9ed0e9a8e",
+        "sha256_in_prefix": "bc38ccb23eae0e0e54cc9f45945c3c46d0907a856ea0c02e4c1311a9ed0e9a8e",
+        "size_in_bytes": 2958
+      },
+      {
+        "_path": "include/patchlevel.h",
+        "path_type": "hardlink",
+        "sha256": "2a04cfcae6df20b2620391dbef02c42945b088215c76746547ee672b8411ca57",
+        "sha256_in_prefix": "2a04cfcae6df20b2620391dbef02c42945b088215c76746547ee672b8411ca57",
+        "size_in_bytes": 1299
+      },
+      {
+        "_path": "include/picklebufobject.h",
+        "path_type": "hardlink",
+        "sha256": "da3dd5626150aa4e00a4a0199baa582b4db9b9362412a44f9ac20ca80b0086ca",
+        "sha256_in_prefix": "da3dd5626150aa4e00a4a0199baa582b4db9b9362412a44f9ac20ca80b0086ca",
+        "size_in_bytes": 846
+      },
+      {
+        "_path": "include/py_curses.h",
+        "path_type": "hardlink",
+        "sha256": "18498ae03ed5fb81815a98e1dde888c9e0ea1c38fead6c7b3698d2583538c7f6",
+        "sha256_in_prefix": "18498ae03ed5fb81815a98e1dde888c9e0ea1c38fead6c7b3698d2583538c7f6",
+        "size_in_bytes": 2474
+      },
+      {
+        "_path": "include/pyarena.h",
+        "path_type": "hardlink",
+        "sha256": "766e5ed190f352fa3d59b57c40a824a6815b6846ece8eb382c100d5eca46bef0",
+        "sha256_in_prefix": "766e5ed190f352fa3d59b57c40a824a6815b6846ece8eb382c100d5eca46bef0",
+        "size_in_bytes": 2744
+      },
+      {
+        "_path": "include/pycapsule.h",
+        "path_type": "hardlink",
+        "sha256": "8fed74eb81e83720caae346011dd6deedb147fd462bf94e679eac5065dfa92aa",
+        "sha256_in_prefix": "8fed74eb81e83720caae346011dd6deedb147fd462bf94e679eac5065dfa92aa",
+        "size_in_bytes": 1725
+      },
+      {
+        "_path": "include/pyconfig.h",
+        "path_type": "hardlink",
+        "sha256": "2eb93eb868e559253f19776b8d97259b22ac3b74f981bf106a480aad194d7dac",
+        "sha256_in_prefix": "2eb93eb868e559253f19776b8d97259b22ac3b74f981bf106a480aad194d7dac",
+        "size_in_bytes": 20281
+      },
+      {
+        "_path": "include/pyctype.h",
+        "path_type": "hardlink",
+        "sha256": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb",
+        "sha256_in_prefix": "10b5ccbc210fd2832e9c34849a3952e8db75f0016add89188358b1da6a8f3dbb",
+        "size_in_bytes": 1387
+      },
+      {
+        "_path": "include/pydebug.h",
+        "path_type": "hardlink",
+        "sha256": "872f99a8bd4d03d9edf3a2d539a137810749c04ee36da531088d3823f74e8e01",
+        "sha256_in_prefix": "872f99a8bd4d03d9edf3a2d539a137810749c04ee36da531088d3823f74e8e01",
+        "size_in_bytes": 1093
+      },
+      {
+        "_path": "include/pydtrace.d",
+        "path_type": "hardlink",
+        "sha256": "9dd7071fac51ba3a1cf21cd24183d285d46176f795fce62c3575555f10f4cad0",
+        "sha256_in_prefix": "9dd7071fac51ba3a1cf21cd24183d285d46176f795fce62c3575555f10f4cad0",
+        "size_in_bytes": 1008
+      },
+      {
+        "_path": "include/pydtrace.h",
+        "path_type": "hardlink",
+        "sha256": "d342948372e46cb0124ba1311ce5ba9941837ac8a137a76b5a532bca03c696e8",
+        "sha256_in_prefix": "d342948372e46cb0124ba1311ce5ba9941837ac8a137a76b5a532bca03c696e8",
+        "size_in_bytes": 2413
+      },
+      {
+        "_path": "include/pyerrors.h",
+        "path_type": "hardlink",
+        "sha256": "deb8cb740e8063a563a6dd6261c1e1e478b7f9e9fd2080e1a24ec4bdda85b487",
+        "sha256_in_prefix": "deb8cb740e8063a563a6dd6261c1e1e478b7f9e9fd2080e1a24ec4bdda85b487",
+        "size_in_bytes": 12427
+      },
+      {
+        "_path": "include/pyexpat.h",
+        "path_type": "hardlink",
+        "sha256": "24eb6f486b4eec69bcd84ec6cc17833040095aabba7a0c4ebe491bb5de02879e",
+        "sha256_in_prefix": "24eb6f486b4eec69bcd84ec6cc17833040095aabba7a0c4ebe491bb5de02879e",
+        "size_in_bytes": 2572
+      },
+      {
+        "_path": "include/pyfpe.h",
+        "path_type": "hardlink",
+        "sha256": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7",
+        "sha256_in_prefix": "ea7bfa7d891a0b5372d8b40a57d1b466b7824296e5c3f8d50b1a7cde084429b7",
+        "size_in_bytes": 444
+      },
+      {
+        "_path": "include/pyframe.h",
+        "path_type": "hardlink",
+        "sha256": "92fa396239229cd523e37349f9ae6e8d990061698c5d7e0770a473ce15b39304",
+        "sha256_in_prefix": "92fa396239229cd523e37349f9ae6e8d990061698c5d7e0770a473ce15b39304",
+        "size_in_bytes": 466
+      },
+      {
+        "_path": "include/pyhash.h",
+        "path_type": "hardlink",
+        "sha256": "5b8e5b1ae6c392c384c16315c137b9fc4f7f7ecd607592221089862872ebafb7",
+        "sha256_in_prefix": "5b8e5b1ae6c392c384c16315c137b9fc4f7f7ecd607592221089862872ebafb7",
+        "size_in_bytes": 4263
+      },
+      {
+        "_path": "include/pylifecycle.h",
+        "path_type": "hardlink",
+        "sha256": "b752d7120786a7cff2b615bc2fa356c89643a6ffc2c3bd54f2c032495e35971e",
+        "sha256_in_prefix": "b752d7120786a7cff2b615bc2fa356c89643a6ffc2c3bd54f2c032495e35971e",
+        "size_in_bytes": 2136
+      },
+      {
+        "_path": "include/pymacconfig.h",
+        "path_type": "hardlink",
+        "sha256": "06a284cd2ccccbac21c5aa2ce5ea1d05d04a4b5e5038e5d55c7fab260ab30e2c",
+        "sha256_in_prefix": "06a284cd2ccccbac21c5aa2ce5ea1d05d04a4b5e5038e5d55c7fab260ab30e2c",
+        "size_in_bytes": 2989
+      },
+      {
+        "_path": "include/pymacro.h",
+        "path_type": "hardlink",
+        "sha256": "4bed498f025583031bf71f5fde5cb589e3af0744e73143b6b074845fff51f7ef",
+        "sha256_in_prefix": "4bed498f025583031bf71f5fde5cb589e3af0744e73143b6b074845fff51f7ef",
+        "size_in_bytes": 4920
+      },
+      {
+        "_path": "include/pymath.h",
+        "path_type": "hardlink",
+        "sha256": "bc79dd324a81e62256ecb8e47c18fe6d9f3aa13f0b121794e728f269b3c97d95",
+        "sha256_in_prefix": "bc79dd324a81e62256ecb8e47c18fe6d9f3aa13f0b121794e728f269b3c97d95",
+        "size_in_bytes": 8580
+      },
+      {
+        "_path": "include/pymem.h",
+        "path_type": "hardlink",
+        "sha256": "edf94548c09b41a33bedb4ae663c722d3dd2f603d088fa58655a0d3b4db61ea9",
+        "sha256_in_prefix": "edf94548c09b41a33bedb4ae663c722d3dd2f603d088fa58655a0d3b4db61ea9",
+        "size_in_bytes": 4406
+      },
+      {
+        "_path": "include/pyport.h",
+        "path_type": "hardlink",
+        "sha256": "cfe73e845ea467a1338618fe9923df60c487b296ca992bc7a836420ebe82eda1",
+        "sha256_in_prefix": "cfe73e845ea467a1338618fe9923df60c487b296ca992bc7a836420ebe82eda1",
+        "size_in_bytes": 31273
+      },
+      {
+        "_path": "include/pystate.h",
+        "path_type": "hardlink",
+        "sha256": "69aafe4b49dbcb969d56ad795aac8b97f4ed48ea233675d83e0ba93423254197",
+        "sha256_in_prefix": "69aafe4b49dbcb969d56ad795aac8b97f4ed48ea233675d83e0ba93423254197",
+        "size_in_bytes": 5250
+      },
+      {
+        "_path": "include/pystrcmp.h",
+        "path_type": "hardlink",
+        "sha256": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88",
+        "sha256_in_prefix": "f401d8338fb6ecf5f12768ee95cd09c262f880b2ee522ca344b890dbdcde4c88",
+        "size_in_bytes": 436
+      },
+      {
+        "_path": "include/pystrhex.h",
+        "path_type": "hardlink",
+        "sha256": "2242f90a9a2bf13a32f0016bb056869193df04230ace468b469b18008f56a0f9",
+        "sha256_in_prefix": "2242f90a9a2bf13a32f0016bb056869193df04230ace468b469b18008f56a0f9",
+        "size_in_bytes": 849
+      },
+      {
+        "_path": "include/pystrtod.h",
+        "path_type": "hardlink",
+        "sha256": "df98a492044f55cf016c008fef3181d77d13f1828b84625b5cb1f460e5f5ed2f",
+        "sha256_in_prefix": "df98a492044f55cf016c008fef3181d77d13f1828b84625b5cb1f460e5f5ed2f",
+        "size_in_bytes": 1483
+      },
+      {
+        "_path": "include/pythonrun.h",
+        "path_type": "hardlink",
+        "sha256": "d9eade9ce776690cefa5782bcdc0b2da6b9eb7b0b9093c1f8c92486ff9540553",
+        "sha256_in_prefix": "d9eade9ce776690cefa5782bcdc0b2da6b9eb7b0b9093c1f8c92486ff9540553",
+        "size_in_bytes": 7673
+      },
+      {
+        "_path": "include/pythread.h",
+        "path_type": "hardlink",
+        "sha256": "f578d2d30051b9474f36916909308665d51d3e9653f62774a628e659b969f8d4",
+        "sha256_in_prefix": "f578d2d30051b9474f36916909308665d51d3e9653f62774a628e659b969f8d4",
+        "size_in_bytes": 5938
+      },
+      {
+        "_path": "include/pytime.h",
+        "path_type": "hardlink",
+        "sha256": "38cea168ea9aef290b79dc337c2948e3f2467383fe2013a93f5cdc926abcfd08",
+        "sha256_in_prefix": "38cea168ea9aef290b79dc337c2948e3f2467383fe2013a93f5cdc926abcfd08",
+        "size_in_bytes": 8928
+      },
+      {
+        "_path": "include/rangeobject.h",
+        "path_type": "hardlink",
+        "sha256": "eb9bbb31cf628ffa8c4452aa7d136941b3e93e43e04d44b51c68ba0b16d56381",
+        "sha256_in_prefix": "eb9bbb31cf628ffa8c4452aa7d136941b3e93e43e04d44b51c68ba0b16d56381",
+        "size_in_bytes": 628
+      },
+      {
+        "_path": "include/setobject.h",
+        "path_type": "hardlink",
+        "sha256": "9035b944aea0eb29c9ffc4490a2c34ea4d2747594766cdbd47ec7e66d61076f3",
+        "sha256_in_prefix": "9035b944aea0eb29c9ffc4490a2c34ea4d2747594766cdbd47ec7e66d61076f3",
+        "size_in_bytes": 3324
+      },
+      {
+        "_path": "include/sliceobject.h",
+        "path_type": "hardlink",
+        "sha256": "3215a02de59673a950b8941a0224474cf0bcb62f617d9afc402f1e17713f9c28",
+        "sha256_in_prefix": "3215a02de59673a950b8941a0224474cf0bcb62f617d9afc402f1e17713f9c28",
+        "size_in_bytes": 2516
+      },
+      {
+        "_path": "include/structmember.h",
+        "path_type": "hardlink",
+        "sha256": "c87f26f3bbaa4d08adb1cea03fd281fca81de0ab583b5ff8e9368825ca461796",
+        "sha256_in_prefix": "c87f26f3bbaa4d08adb1cea03fd281fca81de0ab583b5ff8e9368825ca461796",
+        "size_in_bytes": 2030
+      },
+      {
+        "_path": "include/structseq.h",
+        "path_type": "hardlink",
+        "sha256": "d08c84466646660599c2f6d03af90be06ee8f9f81380a891d9e2a8c8e27e4308",
+        "sha256_in_prefix": "d08c84466646660599c2f6d03af90be06ee8f9f81380a891d9e2a8c8e27e4308",
+        "size_in_bytes": 1390
+      },
+      {
+        "_path": "include/symtable.h",
+        "path_type": "hardlink",
+        "sha256": "9bf7ac8aaef535dc8c304266c3f0dea00d978c6b2940f5bde9898cfa1d774c6c",
+        "sha256_in_prefix": "9bf7ac8aaef535dc8c304266c3f0dea00d978c6b2940f5bde9898cfa1d774c6c",
+        "size_in_bytes": 5307
+      },
+      {
+        "_path": "include/sysmodule.h",
+        "path_type": "hardlink",
+        "sha256": "2c1c21db5c8704de23d1580250a30243ca3a924f14f11e4b54376a3fffd8d76f",
+        "sha256_in_prefix": "2c1c21db5c8704de23d1580250a30243ca3a924f14f11e4b54376a3fffd8d76f",
+        "size_in_bytes": 1242
+      },
+      {
+        "_path": "include/token.h",
+        "path_type": "hardlink",
+        "sha256": "d7e23401dfdde0aea3e903f1b4ffeb144d2849942222c9e42b897383dd6dff4a",
+        "sha256_in_prefix": "d7e23401dfdde0aea3e903f1b4ffeb144d2849942222c9e42b897383dd6dff4a",
+        "size_in_bytes": 2642
+      },
+      {
+        "_path": "include/traceback.h",
+        "path_type": "hardlink",
+        "sha256": "c6db281d9686cf1b6895f7574a05291263b81aaa3f35cd0ca9a2e3219a669b45",
+        "sha256_in_prefix": "c6db281d9686cf1b6895f7574a05291263b81aaa3f35cd0ca9a2e3219a669b45",
+        "size_in_bytes": 584
+      },
+      {
+        "_path": "include/tracemalloc.h",
+        "path_type": "hardlink",
+        "sha256": "0e5e535fbb5e66400b4dcb3d404ff532971ae964b4a11ac4abb6d73991ad24fe",
+        "sha256_in_prefix": "0e5e535fbb5e66400b4dcb3d404ff532971ae964b4a11ac4abb6d73991ad24fe",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "include/tupleobject.h",
+        "path_type": "hardlink",
+        "sha256": "a0659adc9bdffd1980fca036b3b9eabc1a99540435b6e857f071711054ebb3ed",
+        "sha256_in_prefix": "a0659adc9bdffd1980fca036b3b9eabc1a99540435b6e857f071711054ebb3ed",
+        "size_in_bytes": 1614
+      },
+      {
+        "_path": "include/typeslots.h",
+        "path_type": "hardlink",
+        "sha256": "e07cb214d3edb03d5741ad6699b326a58f1c43163b00099eead5592ae02c49d8",
+        "sha256_in_prefix": "e07cb214d3edb03d5741ad6699b326a58f1c43163b00099eead5592ae02c49d8",
+        "size_in_bytes": 2350
+      },
+      {
+        "_path": "include/ucnhash.h",
+        "path_type": "hardlink",
+        "sha256": "a288021d7c33d0d3884e1933cae04d37488d58efe4a399f9348bc2ef17dd010a",
+        "sha256_in_prefix": "a288021d7c33d0d3884e1933cae04d37488d58efe4a399f9348bc2ef17dd010a",
+        "size_in_bytes": 1056
+      },
+      {
+        "_path": "include/unicodeobject.h",
+        "path_type": "hardlink",
+        "sha256": "914063dc48386430088dd6ecc7978944d6030a794ef15b0909afbbf7071e5ba2",
+        "sha256_in_prefix": "914063dc48386430088dd6ecc7978944d6030a794ef15b0909afbbf7071e5ba2",
+        "size_in_bytes": 35426
+      },
+      {
+        "_path": "include/warnings.h",
+        "path_type": "hardlink",
+        "sha256": "d07c5b3d4b5f3b0c651e1d4244cfe7494e312792ece3568a5134dd8169b61eb2",
+        "sha256_in_prefix": "d07c5b3d4b5f3b0c651e1d4244cfe7494e312792ece3568a5134dd8169b61eb2",
+        "size_in_bytes": 1776
+      },
+      {
+        "_path": "include/weakrefobject.h",
+        "path_type": "hardlink",
+        "sha256": "d64920779d0bdf9b1620eb19afa837d0d74df2e076819b90aa95a3aa0a35c009",
+        "sha256_in_prefix": "d64920779d0bdf9b1620eb19afa837d0d74df2e076819b90aa95a3aa0a35c009",
+        "size_in_bytes": 2863
+      },
+      {
+        "_path": "libs/_tkinter.lib",
+        "path_type": "hardlink",
+        "sha256": "1543af2cc67a7a3cdc655bf70c15ba0f51878c3a53bd0fa569466857a2aefbdf",
+        "sha256_in_prefix": "1543af2cc67a7a3cdc655bf70c15ba0f51878c3a53bd0fa569466857a2aefbdf",
+        "size_in_bytes": 1750
+      },
+      {
+        "_path": "libs/python3.lib",
+        "path_type": "hardlink",
+        "sha256": "d1a4948b6b5d3b9b188fd17fc89b60c68bd9d589a25fb1f733e194a8cdefdbee",
+        "sha256_in_prefix": "d1a4948b6b5d3b9b188fd17fc89b60c68bd9d589a25fb1f733e194a8cdefdbee",
+        "size_in_bytes": 173088
+      },
+      {
+        "_path": "libs/python39.lib",
+        "path_type": "hardlink",
+        "sha256": "58d48dbfa28a3daca69e5d03c0544a0c7f227f47528c3aedc25baa579b218121",
+        "sha256_in_prefix": "58d48dbfa28a3daca69e5d03c0544a0c7f227f47528c3aedc25baa579b218121",
+        "size_in_bytes": 362520
+      },
+      {
+        "_path": "python.exe",
+        "path_type": "hardlink",
+        "sha256": "7b43ac317d5f79012ad097559345e0e4597cfcf2016e209d6643aaf2c3be8223",
+        "sha256_in_prefix": "7b43ac317d5f79012ad097559345e0e4597cfcf2016e209d6643aaf2c3be8223",
+        "size_in_bytes": 107792
+      },
+      {
+        "_path": "python.pdb",
+        "file_mode": "binary",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:\\b\\abs_7bzfc4gc9u\\croot\\python-split_1733933805847\\_h_env",
+        "sha256": "d70a5d739057c2272fd7587680e3f683f0fa4f0d9eb2af2cae1b165e3def540d",
+        "sha256_in_prefix": "d70a5d739057c2272fd7587680e3f683f0fa4f0d9eb2af2cae1b165e3def540d",
+        "size_in_bytes": 471040
+      },
+      {
+        "_path": "python3.dll",
+        "path_type": "hardlink",
+        "sha256": "581a231f9464c8c372e96ee0eed2def9f148a547c6fb9ec7a950cfb693128a14",
+        "sha256_in_prefix": "581a231f9464c8c372e96ee0eed2def9f148a547c6fb9ec7a950cfb693128a14",
+        "size_in_bytes": 64272
+      },
+      {
+        "_path": "python39.dll",
+        "path_type": "hardlink",
+        "sha256": "5ac9d6cac7a3aa28b1c9abe7ad956ca1a23ca1adf4ef93e1297fe9a31da3d449",
+        "sha256_in_prefix": "5ac9d6cac7a3aa28b1c9abe7ad956ca1a23ca1adf4ef93e1297fe9a31da3d449",
+        "size_in_bytes": 4537616
+      },
+      {
+        "_path": "python39.pdb",
+        "path_type": "hardlink",
+        "sha256": "fc09b3dc8ddb8ffcb494db61af4e9e98e4fe00c09204ecbcbde4832d36fa755b",
+        "sha256_in_prefix": "fc09b3dc8ddb8ffcb494db61af4e9e98e4fe00c09204ecbcbde4832d36fa755b",
+        "size_in_bytes": 13742080
+      },
+      {
+        "_path": "pythonw.exe",
+        "path_type": "hardlink",
+        "sha256": "183424f45ca3f70655377557dd3062e09d9464eb192b4991ea229984447df249",
+        "sha256_in_prefix": "183424f45ca3f70655377557dd3062e09d9464eb192b4991ea229984447df249",
+        "size_in_bytes": 106768
+      },
+      {
+        "_path": "pythonw.pdb",
+        "file_mode": "binary",
+        "path_type": "hardlink",
+        "prefix_placeholder": "C:\\b\\abs_7bzfc4gc9u\\croot\\python-split_1733933805847\\_h_env",
+        "sha256": "674fa230995a1403bbcdbf7cc7509777c06902129ff2e7b5c3395390b6085494",
+        "sha256_in_prefix": "674fa230995a1403bbcdbf7cc7509777c06902129ff2e7b5c3395390b6085494",
+        "size_in_bytes": 446464
+      },
+      {
+        "_path": "tcl/dde1.4/pkgIndex.tcl",
+        "path_type": "hardlink",
+        "sha256": "64d08a3abcb271db3af043c535e045f7c325348d87a349a76864637baedd2554",
+        "sha256_in_prefix": "64d08a3abcb271db3af043c535e045f7c325348d87a349a76864637baedd2554",
+        "size_in_bytes": 474
+      },
+      {
+        "_path": "tcl/dde1.4/tcldde14.dll",
+        "path_type": "hardlink",
+        "sha256": "fc6775823173014dfc085eb53942a24c1de114d5081cd5c25c040c4c2c07f6ad",
+        "sha256_in_prefix": "fc6775823173014dfc085eb53942a24c1de114d5081cd5c25c040c4c2c07f6ad",
+        "size_in_bytes": 37136
+      },
+      {
+        "_path": "tcl/nmake/nmakehlp.c",
+        "path_type": "hardlink",
+        "sha256": "3d4c390698ea24cb1c2ab0166c7c302ec056d841dc9f4b01979128824bcfc504",
+        "sha256_in_prefix": "3d4c390698ea24cb1c2ab0166c7c302ec056d841dc9f4b01979128824bcfc504",
+        "size_in_bytes": 21940
+      },
+      {
+        "_path": "tcl/nmake/rules.vc",
+        "path_type": "hardlink",
+        "sha256": "8fbd0a823a6ffa95c468c6a132c9fcbfecea21f0a47600a735ccdef50bc1e2b5",
+        "sha256_in_prefix": "8fbd0a823a6ffa95c468c6a132c9fcbfecea21f0a47600a735ccdef50bc1e2b5",
+        "size_in_bytes": 62054
+      },
+      {
+        "_path": "tcl/nmake/targets.vc",
+        "path_type": "hardlink",
+        "sha256": "48f59ba7c8050de1ce04ede45f1f8a8488cfe7748bf9a0d845d550cd31451e2b",
+        "sha256_in_prefix": "48f59ba7c8050de1ce04ede45f1f8a8488cfe7748bf9a0d845d550cd31451e2b",
+        "size_in_bytes": 2606
+      },
+      {
+        "_path": "tcl/nmake/tcl.nmake",
+        "path_type": "hardlink",
+        "sha256": "03589b111b1a9a4daca7fc3014f9f0ade84e875948be925e30726423c063089e",
+        "sha256_in_prefix": "03589b111b1a9a4daca7fc3014f9f0ade84e875948be925e30726423c063089e",
+        "size_in_bytes": 87
+      },
+      {
+        "_path": "tcl/reg1.3/pkgIndex.tcl",
+        "path_type": "hardlink",
+        "sha256": "1bd0fc8cba2bb1cdd5e5cfcc614b0ef4c8cf4698904d1e48c0f103519c5579e0",
+        "sha256_in_prefix": "1bd0fc8cba2bb1cdd5e5cfcc614b0ef4c8cf4698904d1e48c0f103519c5579e0",
+        "size_in_bytes": 367
+      },
+      {
+        "_path": "tcl/reg1.3/tclreg13.dll",
+        "path_type": "hardlink",
+        "sha256": "17c46d7d33d3d226d88a060fc6f440e98507eb2c1d2c30b22c6585dac5130c0f",
+        "sha256_in_prefix": "17c46d7d33d3d226d88a060fc6f440e98507eb2c1d2c30b22c6585dac5130c0f",
+        "size_in_bytes": 34064
+      },
+      {
+        "_path": "tcl/tcl8.6/auto.tcl",
+        "path_type": "hardlink",
+        "sha256": "517204ee436d08efc287abc97433c3bffcaf42ec6592a3009b9fd3b985ad772c",
+        "sha256_in_prefix": "517204ee436d08efc287abc97433c3bffcaf42ec6592a3009b9fd3b985ad772c",
+        "size_in_bytes": 21523
+      },
+      {
+        "_path": "tcl/tcl8.6/clock.tcl",
+        "path_type": "hardlink",
+        "sha256": "1947f8b188ab4ab6aa72ea68a58d2d9add0894fdf320f6b074eae0f198368fb7",
+        "sha256_in_prefix": "1947f8b188ab4ab6aa72ea68a58d2d9add0894fdf320f6b074eae0f198368fb7",
+        "size_in_bytes": 133439
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/ascii.enc",
+        "path_type": "hardlink",
+        "sha256": "fb87bf197f4f485b08ea81f7534bc07d9c3a538d022424be11011a1fe3c413fd",
+        "sha256_in_prefix": "fb87bf197f4f485b08ea81f7534bc07d9c3a538d022424be11011a1fe3c413fd",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/big5.enc",
+        "path_type": "hardlink",
+        "sha256": "ad1ed201b69855bfd353bf969dfc55576da35a963abf1bf7fc6d8b5142a61a61",
+        "sha256_in_prefix": "ad1ed201b69855bfd353bf969dfc55576da35a963abf1bf7fc6d8b5142a61a61",
+        "size_in_bytes": 94389
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cns11643.enc",
+        "path_type": "hardlink",
+        "sha256": "8924545cc92584169138aadb64683c07bbf846a57014c2e668d23b63f43f3610",
+        "sha256_in_prefix": "8924545cc92584169138aadb64683c07bbf846a57014c2e668d23b63f43f3610",
+        "size_in_bytes": 98634
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp1250.enc",
+        "path_type": "hardlink",
+        "sha256": "e2991a6f7a7a4d8d3c4c97947298fd5bacb3eaa2f898cee17f5e21a9861b9626",
+        "sha256_in_prefix": "e2991a6f7a7a4d8d3c4c97947298fd5bacb3eaa2f898cee17f5e21a9861b9626",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp1251.enc",
+        "path_type": "hardlink",
+        "sha256": "0aa66dff8a7ae570fee83a803f8f5391d9f0c9bd6311796592d9b6e8e36be6fc",
+        "sha256_in_prefix": "0aa66dff8a7ae570fee83a803f8f5391d9f0c9bd6311796592d9b6e8e36be6fc",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp1252.enc",
+        "path_type": "hardlink",
+        "sha256": "741859cf238c3a63bbb20ec6ed51e46451372bb221cfff438297d261d0561c2e",
+        "sha256_in_prefix": "741859cf238c3a63bbb20ec6ed51e46451372bb221cfff438297d261d0561c2e",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp1253.enc",
+        "path_type": "hardlink",
+        "sha256": "5b8d47451f847c1bde12caca3739ca29860553c0b6399ee990d51b26f9a69722",
+        "sha256_in_prefix": "5b8d47451f847c1bde12caca3739ca29860553c0b6399ee990d51b26f9a69722",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp1254.enc",
+        "path_type": "hardlink",
+        "sha256": "31639ca96a4d3602d59bd012540fe179917e0561cb11a0d0b61f1b950eb76911",
+        "sha256_in_prefix": "31639ca96a4d3602d59bd012540fe179917e0561cb11a0d0b61f1b950eb76911",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp1255.enc",
+        "path_type": "hardlink",
+        "sha256": "47576cae321c80e69c7f35205639680bf28010111e86e228ed191b084fac6b91",
+        "sha256_in_prefix": "47576cae321c80e69c7f35205639680bf28010111e86e228ed191b084fac6b91",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp1256.enc",
+        "path_type": "hardlink",
+        "sha256": "29340ea8e5ad3532bf67fa77cc852f055081b1238925cb109908aa72804ccc04",
+        "sha256_in_prefix": "29340ea8e5ad3532bf67fa77cc852f055081b1238925cb109908aa72804ccc04",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp1257.enc",
+        "path_type": "hardlink",
+        "sha256": "c15ab85438728bf2c60d72b1a66af80e8b1ce3cf5eb08ba6421ff1b2f73acdf4",
+        "sha256_in_prefix": "c15ab85438728bf2c60d72b1a66af80e8b1ce3cf5eb08ba6421ff1b2f73acdf4",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp1258.enc",
+        "path_type": "hardlink",
+        "sha256": "29d93dee7c01b2264778bc6b75f6ef76ea6ac53e9f4a334d83707229e7f482d2",
+        "sha256_in_prefix": "29d93dee7c01b2264778bc6b75f6ef76ea6ac53e9f4a334d83707229e7f482d2",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp437.enc",
+        "path_type": "hardlink",
+        "sha256": "e5613c04d3d2ee44ccad85ae53a37c257674491c540836e5d942bbcc4e4a8db4",
+        "sha256_in_prefix": "e5613c04d3d2ee44ccad85ae53a37c257674491c540836e5d942bbcc4e4a8db4",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp737.enc",
+        "path_type": "hardlink",
+        "sha256": "a0415f14f5d72ad24e9c3a5c91517a0e3d22e1adbc3505c0c6e918b961f7a07d",
+        "sha256_in_prefix": "a0415f14f5d72ad24e9c3a5c91517a0e3d22e1adbc3505c0c6e918b961f7a07d",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp775.enc",
+        "path_type": "hardlink",
+        "sha256": "c3c6542e902dec2c44ddcfd8b5cb7abf309b0413a7ced1614dc0b20cf7c5e35f",
+        "sha256_in_prefix": "c3c6542e902dec2c44ddcfd8b5cb7abf309b0413a7ced1614dc0b20cf7c5e35f",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp850.enc",
+        "path_type": "hardlink",
+        "sha256": "13df611f429a9b331da1b34f3c718cccaf0bd4ab44f71a9c632197987b4d643b",
+        "sha256_in_prefix": "13df611f429a9b331da1b34f3c718cccaf0bd4ab44f71a9c632197987b4d643b",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp852.enc",
+        "path_type": "hardlink",
+        "sha256": "f3a18a8c7934f6586f023477e08d3f9d5ead9a45e9e58a3f8d018af9bb13f868",
+        "sha256_in_prefix": "f3a18a8c7934f6586f023477e08d3f9d5ead9a45e9e58a3f8d018af9bb13f868",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp855.enc",
+        "path_type": "hardlink",
+        "sha256": "e64fd2e639da6f654d9bfbb2266f9432259a6a55941622f5cddc3797e382eb0a",
+        "sha256_in_prefix": "e64fd2e639da6f654d9bfbb2266f9432259a6a55941622f5cddc3797e382eb0a",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp857.enc",
+        "path_type": "hardlink",
+        "sha256": "b6cd5c6f2b54d89142679d599ed0a5dee6955a3b3f6b6673e46afe7a5a303cdc",
+        "sha256_in_prefix": "b6cd5c6f2b54d89142679d599ed0a5dee6955a3b3f6b6673e46afe7a5a303cdc",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp860.enc",
+        "path_type": "hardlink",
+        "sha256": "804efa345c5bbbad2449c318a7a3f5b31f4234712aad23dc49b3fb5aa33b7a57",
+        "sha256_in_prefix": "804efa345c5bbbad2449c318a7a3f5b31f4234712aad23dc49b3fb5aa33b7a57",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp861.enc",
+        "path_type": "hardlink",
+        "sha256": "4b7e76aeb75289faca76434ea6e9874e9504ad2bc3d8d47550eadbcc8294857e",
+        "sha256_in_prefix": "4b7e76aeb75289faca76434ea6e9874e9504ad2bc3d8d47550eadbcc8294857e",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp862.enc",
+        "path_type": "hardlink",
+        "sha256": "6c15cb256b1c22170292589c6f589e64e164eb36ec7e84f0bd48149babb7c5fc",
+        "sha256_in_prefix": "6c15cb256b1c22170292589c6f589e64e164eb36ec7e84f0bd48149babb7c5fc",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp863.enc",
+        "path_type": "hardlink",
+        "sha256": "232d6fe34d7151920232eaae9c515f36400ab64136dcc5b802d6245ac6f5d56b",
+        "sha256_in_prefix": "232d6fe34d7151920232eaae9c515f36400ab64136dcc5b802d6245ac6f5d56b",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp864.enc",
+        "path_type": "hardlink",
+        "sha256": "81bebfd9a61e9f17495763b68d57742fab2a1a43871015699a2c8e5fded4ec19",
+        "sha256_in_prefix": "81bebfd9a61e9f17495763b68d57742fab2a1a43871015699a2c8e5fded4ec19",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp865.enc",
+        "path_type": "hardlink",
+        "sha256": "ada1a52064ee93ebe6f8a5d101d01f8776038e12f21a5ca1c006ee833577c705",
+        "sha256_in_prefix": "ada1a52064ee93ebe6f8a5d101d01f8776038e12f21a5ca1c006ee833577c705",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp866.enc",
+        "path_type": "hardlink",
+        "sha256": "32a45deba933c7ed99141535087a4c99ba79802175e3f762aca6eb941157f85a",
+        "sha256_in_prefix": "32a45deba933c7ed99141535087a4c99ba79802175e3f762aca6eb941157f85a",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp869.enc",
+        "path_type": "hardlink",
+        "sha256": "afe6ed6eb5d07c45b6b928a48bc5ef57efcf61602d36ff9fbde4a8ea3fa6df75",
+        "sha256_in_prefix": "afe6ed6eb5d07c45b6b928a48bc5ef57efcf61602d36ff9fbde4a8ea3fa6df75",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp874.enc",
+        "path_type": "hardlink",
+        "sha256": "4f05f31ca026bbfeeee49ed86504cb060784137a9cfae0e5954d276e837ab5de",
+        "sha256_in_prefix": "4f05f31ca026bbfeeee49ed86504cb060784137a9cfae0e5954d276e837ab5de",
+        "size_in_bytes": 1110
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp932.enc",
+        "path_type": "hardlink",
+        "sha256": "6d1b512110beaf2cd1296ac878f51d567848ab4a1ced4f18c72806bb136b3d23",
+        "sha256_in_prefix": "6d1b512110beaf2cd1296ac878f51d567848ab4a1ced4f18c72806bb136b3d23",
+        "size_in_bytes": 49008
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp936.enc",
+        "path_type": "hardlink",
+        "sha256": "b6ec2be0504ca62b9d1b6857f6baa13ffac5a567d4432f4eab98adc830f5d9c3",
+        "sha256_in_prefix": "b6ec2be0504ca62b9d1b6857f6baa13ffac5a567d4432f4eab98adc830f5d9c3",
+        "size_in_bytes": 134671
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp949.enc",
+        "path_type": "hardlink",
+        "sha256": "477f8b79b67f4a22c963ee65b9b387dbd8e4b8f62d800b0a51d2276580c6adbb",
+        "sha256_in_prefix": "477f8b79b67f4a22c963ee65b9b387dbd8e4b8f62d800b0a51d2276580c6adbb",
+        "size_in_bytes": 132551
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/cp950.enc",
+        "path_type": "hardlink",
+        "sha256": "f80e05533d1a1494c32f9412e9ad2d9c11faf9ae0668a6f9d1fa5ceedc6870e2",
+        "sha256_in_prefix": "f80e05533d1a1494c32f9412e9ad2d9c11faf9ae0668a6f9d1fa5ceedc6870e2",
+        "size_in_bytes": 93330
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/dingbats.enc",
+        "path_type": "hardlink",
+        "sha256": "eb9b262e4d179268e6f017c0d4ef0e7034e31a5b4893595d150640ca1f6a1c45",
+        "sha256_in_prefix": "eb9b262e4d179268e6f017c0d4ef0e7034e31a5b4893595d150640ca1f6a1c45",
+        "size_in_bytes": 1113
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/ebcdic.enc",
+        "path_type": "hardlink",
+        "sha256": "165be658ab7d61ffc3df1e2f1438c2f9fcee6808a756316302157f44e6d3acd7",
+        "sha256_in_prefix": "165be658ab7d61ffc3df1e2f1438c2f9fcee6808a756316302157f44e6d3acd7",
+        "size_in_bytes": 1073
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/euc-cn.enc",
+        "path_type": "hardlink",
+        "sha256": "1700af47dc012a48cec89cf1dfae6d1d0d2f40ed731eff6ca55296a055a11c00",
+        "sha256_in_prefix": "1700af47dc012a48cec89cf1dfae6d1d0d2f40ed731eff6ca55296a055a11c00",
+        "size_in_bytes": 86971
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/euc-jp.enc",
+        "path_type": "hardlink",
+        "sha256": "a3c916ba16bcac9faa5a1ccc62aca61452d581cd8ba3ee07ec39122c697274c9",
+        "sha256_in_prefix": "a3c916ba16bcac9faa5a1ccc62aca61452d581cd8ba3ee07ec39122c697274c9",
+        "size_in_bytes": 83890
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/euc-kr.enc",
+        "path_type": "hardlink",
+        "sha256": "5448643398685456a11cbb93af2321f70b8659e2fff3ccc534b4d53bd2f38c89",
+        "sha256_in_prefix": "5448643398685456a11cbb93af2321f70b8659e2fff3ccc534b4d53bd2f38c89",
+        "size_in_bytes": 95451
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/gb12345.enc",
+        "path_type": "hardlink",
+        "sha256": "b4894aedd2d5b5ae54b6d2840f7c89a88e9308efd288f179e65936e172ef4b0d",
+        "sha256_in_prefix": "b4894aedd2d5b5ae54b6d2840f7c89a88e9308efd288f179e65936e172ef4b0d",
+        "size_in_bytes": 88033
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/gb1988.enc",
+        "path_type": "hardlink",
+        "sha256": "acd50951f81566c8d823670f9957b2479102eb5ae4cf558453e1d8436a9e31ff",
+        "sha256_in_prefix": "acd50951f81566c8d823670f9957b2479102eb5ae4cf558453e1d8436a9e31ff",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/gb2312-raw.enc",
+        "path_type": "hardlink",
+        "sha256": "c445e4c9f676ae997d2dda2bbc107b746f3547d85f39479951c56f46275ee355",
+        "sha256_in_prefix": "c445e4c9f676ae997d2dda2bbc107b746f3547d85f39479951c56f46275ee355",
+        "size_in_bytes": 85912
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/gb2312.enc",
+        "path_type": "hardlink",
+        "sha256": "1700af47dc012a48cec89cf1dfae6d1d0d2f40ed731eff6ca55296a055a11c00",
+        "sha256_in_prefix": "1700af47dc012a48cec89cf1dfae6d1d0d2f40ed731eff6ca55296a055a11c00",
+        "size_in_bytes": 86971
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso2022-jp.enc",
+        "path_type": "hardlink",
+        "sha256": "98074c85650a420a095ada9138da3a8a0aa4027be47ea1e97a596f319eb084e9",
+        "sha256_in_prefix": "98074c85650a420a095ada9138da3a8a0aa4027be47ea1e97a596f319eb084e9",
+        "size_in_bytes": 204
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso2022-kr.enc",
+        "path_type": "hardlink",
+        "sha256": "234811fc8b0f8ff2b847d9cc3982f1699df1d21a43c74dce45ba855d22520007",
+        "sha256_in_prefix": "234811fc8b0f8ff2b847d9cc3982f1699df1d21a43c74dce45ba855d22520007",
+        "size_in_bytes": 122
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso2022.enc",
+        "path_type": "hardlink",
+        "sha256": "741b4c842557eed2952936204d0ae9c35fa3a0f02f826d94c50c46976291797c",
+        "sha256_in_prefix": "741b4c842557eed2952936204d0ae9c35fa3a0f02f826d94c50c46976291797c",
+        "size_in_bytes": 240
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-1.enc",
+        "path_type": "hardlink",
+        "sha256": "a9cb4f4ca111608f882729bc5eb1c2f15530c515ef02dd2ca62f2d8dc5a210cf",
+        "sha256_in_prefix": "a9cb4f4ca111608f882729bc5eb1c2f15530c515ef02dd2ca62f2d8dc5a210cf",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-10.enc",
+        "path_type": "hardlink",
+        "sha256": "48f4a239c25354f0e9f83a39f15d4632bb18a9c33e60c671c67307159917eced",
+        "sha256_in_prefix": "48f4a239c25354f0e9f83a39f15d4632bb18a9c33e60c671c67307159917eced",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-11.enc",
+        "path_type": "hardlink",
+        "sha256": "21e769c5a66e4d12d6e7db24022e92af1ec0d0331fe3c8c605654f239c0f3640",
+        "sha256_in_prefix": "21e769c5a66e4d12d6e7db24022e92af1ec0d0331fe3c8c605654f239c0f3640",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-13.enc",
+        "path_type": "hardlink",
+        "sha256": "3271d39d7b4dcd841e8e5d5153d1b8837718b88fefec73dc37d314816eefe5e5",
+        "sha256_in_prefix": "3271d39d7b4dcd841e8e5d5153d1b8837718b88fefec73dc37d314816eefe5e5",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-14.enc",
+        "path_type": "hardlink",
+        "sha256": "f0a5675027fb1ca34b4e4128d24c2968cd275890569a32a86afa4994ce4983e0",
+        "sha256_in_prefix": "f0a5675027fb1ca34b4e4128d24c2968cd275890569a32a86afa4994ce4983e0",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-15.enc",
+        "path_type": "hardlink",
+        "sha256": "c74e8e23a0ff0d5dea7c318ca20dc817da4e57b0dd61b3361fc0d5098a9316fe",
+        "sha256_in_prefix": "c74e8e23a0ff0d5dea7c318ca20dc817da4e57b0dd61b3361fc0d5098a9316fe",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-16.enc",
+        "path_type": "hardlink",
+        "sha256": "640d977ec1d22b555c5075798da009e3523e8f55f29be22a3050cd1b4ef7b80e",
+        "sha256_in_prefix": "640d977ec1d22b555c5075798da009e3523e8f55f29be22a3050cd1b4ef7b80e",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-2.enc",
+        "path_type": "hardlink",
+        "sha256": "76949b03f57041b07f41902bd7505ab3594d79aa8f7bdeed5f0481004b10cbc3",
+        "sha256_in_prefix": "76949b03f57041b07f41902bd7505ab3594d79aa8f7bdeed5f0481004b10cbc3",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-3.enc",
+        "path_type": "hardlink",
+        "sha256": "1f51e7bda64d466c16fee9a120bbe3353a10ceb9dab119ffa326779ba78d8c5d",
+        "sha256_in_prefix": "1f51e7bda64d466c16fee9a120bbe3353a10ceb9dab119ffa326779ba78d8c5d",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-4.enc",
+        "path_type": "hardlink",
+        "sha256": "66b3cf994f0b5e0103d13e812958320afb555c91e3f81b579d4cbf231e6a0805",
+        "sha256_in_prefix": "66b3cf994f0b5e0103d13e812958320afb555c91e3f81b579d4cbf231e6a0805",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-5.enc",
+        "path_type": "hardlink",
+        "sha256": "3130bf26da0c840c1e02203a90c3b1c38966fb203130e2fbb3dd7cb3865a3539",
+        "sha256_in_prefix": "3130bf26da0c840c1e02203a90c3b1c38966fb203130e2fbb3dd7cb3865a3539",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-6.enc",
+        "path_type": "hardlink",
+        "sha256": "cb71909bf01a3a7a4c7396359da06d206b58a42ad68192ce37169d6640d46e13",
+        "sha256_in_prefix": "cb71909bf01a3a7a4c7396359da06d206b58a42ad68192ce37169d6640d46e13",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-7.enc",
+        "path_type": "hardlink",
+        "sha256": "76f6bc85fc9cb89bc3f94d36275ab23c740ba17fd36ec8907479da3a885415ea",
+        "sha256_in_prefix": "76f6bc85fc9cb89bc3f94d36275ab23c740ba17fd36ec8907479da3a885415ea",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-8.enc",
+        "path_type": "hardlink",
+        "sha256": "865e3665743b5faba3e1ad6aa55515a666bd05da6266879d9b66c98905daff3c",
+        "sha256_in_prefix": "865e3665743b5faba3e1ad6aa55515a666bd05da6266879d9b66c98905daff3c",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/iso8859-9.enc",
+        "path_type": "hardlink",
+        "sha256": "cf51e867dde2f19553d98feec45a075c4b4f480fb1edadb3d8dad1ebea9299f3",
+        "sha256_in_prefix": "cf51e867dde2f19553d98feec45a075c4b4f480fb1edadb3d8dad1ebea9299f3",
+        "size_in_bytes": 1114
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/jis0201.enc",
+        "path_type": "hardlink",
+        "sha256": "61b14a7c312366f79bb45f02c6b7ee362e6f51cbad5e479e563c7f7e785db654",
+        "sha256_in_prefix": "61b14a7c312366f79bb45f02c6b7ee362e6f51cbad5e479e563c7f7e785db654",
+        "size_in_bytes": 1112
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/jis0208.enc",
+        "path_type": "hardlink",
+        "sha256": "f6b1c6ac5f5fc4e990a7a1aac16a406012040936431befe7d2b6cd1da9e422c4",
+        "sha256_in_prefix": "f6b1c6ac5f5fc4e990a7a1aac16a406012040936431befe7d2b6cd1da9e422c4",
+        "size_in_bytes": 81772
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/jis0212.enc",
+        "path_type": "hardlink",
+        "sha256": "785cfc5f5d9cb06db8061730ab0016a0f70d0b59f6787d2a3cbb8d5779c99706",
+        "sha256_in_prefix": "785cfc5f5d9cb06db8061730ab0016a0f70d0b59f6787d2a3cbb8d5779c99706",
+        "size_in_bytes": 72133
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/koi8-r.enc",
+        "path_type": "hardlink",
+        "sha256": "0e43244bfc4f33facb844b9e00270a1a4c24dc59b8a9b95104e2d788bb2f59fd",
+        "sha256_in_prefix": "0e43244bfc4f33facb844b9e00270a1a4c24dc59b8a9b95104e2d788bb2f59fd",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/koi8-u.enc",
+        "path_type": "hardlink",
+        "sha256": "ed04d5b977b8c8944d8760b713ff061292da5634bcbb67cdfb1c3a6ff5378c81",
+        "sha256_in_prefix": "ed04d5b977b8c8944d8760b713ff061292da5634bcbb67cdfb1c3a6ff5378c81",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/ksc5601.enc",
+        "path_type": "hardlink",
+        "sha256": "9b27fe7e7054f36e279993f19e52e18ac03360d117ae80c42b4e984a97c590aa",
+        "sha256_in_prefix": "9b27fe7e7054f36e279993f19e52e18ac03360d117ae80c42b4e984a97c590aa",
+        "size_in_bytes": 94393
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macCentEuro.enc",
+        "path_type": "hardlink",
+        "sha256": "81eca6840b87f2def9fcdd171a55c2d71a49386d88401ce927ae57d7ddd7aaaa",
+        "sha256_in_prefix": "81eca6840b87f2def9fcdd171a55c2d71a49386d88401ce927ae57d7ddd7aaaa",
+        "size_in_bytes": 1116
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macCroatian.enc",
+        "path_type": "hardlink",
+        "sha256": "bbe6f5ebb5eab08c91df7d524faf39b03aa8b9f84c67aba0553a84ec56668cb9",
+        "sha256_in_prefix": "bbe6f5ebb5eab08c91df7d524faf39b03aa8b9f84c67aba0553a84ec56668cb9",
+        "size_in_bytes": 1116
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macCyrillic.enc",
+        "path_type": "hardlink",
+        "sha256": "76efe571adda7aed467f146cb0bd3a2351f2a720508ea0642c419f5347789caa",
+        "sha256_in_prefix": "76efe571adda7aed467f146cb0bd3a2351f2a720508ea0642c419f5347789caa",
+        "size_in_bytes": 1116
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macDingbats.enc",
+        "path_type": "hardlink",
+        "sha256": "062e31d48dc33160999074e49205e08c3655dff91c2c87f254522e6ebce2dd96",
+        "sha256_in_prefix": "062e31d48dc33160999074e49205e08c3655dff91c2c87f254522e6ebce2dd96",
+        "size_in_bytes": 1116
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macGreek.enc",
+        "path_type": "hardlink",
+        "sha256": "1aabe561b5c944abd11c293d4acac0f3a4a5a9e84a0342d066f4e3e992348895",
+        "sha256_in_prefix": "1aabe561b5c944abd11c293d4acac0f3a4a5a9e84a0342d066f4e3e992348895",
+        "size_in_bytes": 1113
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macIceland.enc",
+        "path_type": "hardlink",
+        "sha256": "6fd08ce6fba521d51e8058de5c2dbd6583b80306a8be7d015361f76314e70a35",
+        "sha256_in_prefix": "6fd08ce6fba521d51e8058de5c2dbd6583b80306a8be7d015361f76314e70a35",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macJapan.enc",
+        "path_type": "hardlink",
+        "sha256": "47007d9ebf4d34c6ce3599e50afc7c1cf8129b88994de2c2a857c09003f9cd2b",
+        "sha256_in_prefix": "47007d9ebf4d34c6ce3599e50afc7c1cf8129b88994de2c2a857c09003f9cd2b",
+        "size_in_bytes": 48813
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macRoman.enc",
+        "path_type": "hardlink",
+        "sha256": "c83d971d6bc0284ef323c197896e38c57a5ff44784e451ec2997eda70c0dd85c",
+        "sha256_in_prefix": "c83d971d6bc0284ef323c197896e38c57a5ff44784e451ec2997eda70c0dd85c",
+        "size_in_bytes": 1113
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macRomania.enc",
+        "path_type": "hardlink",
+        "sha256": "0b805daf21d37d702617a8c72c7345f857695108d905ff378791f291cea150f0",
+        "sha256_in_prefix": "0b805daf21d37d702617a8c72c7345f857695108d905ff378791f291cea150f0",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macThai.enc",
+        "path_type": "hardlink",
+        "sha256": "a1802a2feb01b255ec7c17425eee4525372df8ce226f4047d149172eb438f913",
+        "sha256_in_prefix": "a1802a2feb01b255ec7c17425eee4525372df8ce226f4047d149172eb438f913",
+        "size_in_bytes": 1112
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macTurkish.enc",
+        "path_type": "hardlink",
+        "sha256": "afb66138ebe9b87d8b070fe3b6e7d1a05ed508571e9e5b166c3314069d59b4e4",
+        "sha256_in_prefix": "afb66138ebe9b87d8b070fe3b6e7d1a05ed508571e9e5b166c3314069d59b4e4",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/macUkraine.enc",
+        "path_type": "hardlink",
+        "sha256": "f7e11736c9ff30102b31ec72272754110193b347433f4b364921e8f131c92bf0",
+        "sha256_in_prefix": "f7e11736c9ff30102b31ec72272754110193b347433f4b364921e8f131c92bf0",
+        "size_in_bytes": 1115
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/shiftjis.enc",
+        "path_type": "hardlink",
+        "sha256": "4a15ed210126bcdae32543f60eb1a0677f985f32d49fce923b9fae8c5bcf3da4",
+        "sha256_in_prefix": "4a15ed210126bcdae32543f60eb1a0677f985f32d49fce923b9fae8c5bcf3da4",
+        "size_in_bytes": 42552
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/symbol.enc",
+        "path_type": "hardlink",
+        "sha256": "9660537a7b62996478555c6f57c1962c78fb3972f19370b2e395c44842818a1f",
+        "sha256_in_prefix": "9660537a7b62996478555c6f57c1962c78fb3972f19370b2e395c44842818a1f",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/encoding/tis-620.enc",
+        "path_type": "hardlink",
+        "sha256": "50b62381d6edd4219f4292bfdc365954491b23360de7c08033e7218a3d29c970",
+        "sha256_in_prefix": "50b62381d6edd4219f4292bfdc365954491b23360de7c08033e7218a3d29c970",
+        "size_in_bytes": 1112
+      },
+      {
+        "_path": "tcl/tcl8.6/history.tcl",
+        "path_type": "hardlink",
+        "sha256": "5123db837eadf45712ea7d449bc40bfd3e8e16d3d71e7d0ce9a32f164973d767",
+        "sha256_in_prefix": "5123db837eadf45712ea7d449bc40bfd3e8e16d3d71e7d0ce9a32f164973d767",
+        "size_in_bytes": 8235
+      },
+      {
+        "_path": "tcl/tcl8.6/http1.0/http.tcl",
+        "path_type": "hardlink",
+        "sha256": "8c474095a3aba7df5b488f3d35240d6de729e57153980c2a898728b8c407a727",
+        "sha256_in_prefix": "8c474095a3aba7df5b488f3d35240d6de729e57153980c2a898728b8c407a727",
+        "size_in_bytes": 10066
+      },
+      {
+        "_path": "tcl/tcl8.6/http1.0/pkgIndex.tcl",
+        "path_type": "hardlink",
+        "sha256": "77265723959c092897c2449c5b7768ca72d0efcd8c505bddbb7a84f6aa401339",
+        "sha256_in_prefix": "77265723959c092897c2449c5b7768ca72d0efcd8c505bddbb7a84f6aa401339",
+        "size_in_bytes": 746
+      },
+      {
+        "_path": "tcl/tcl8.6/init.tcl",
+        "path_type": "hardlink",
+        "sha256": "331bcf0f9f635bd57c3384f2237260d074708b0975c700cfcbdb285f5f59ab1f",
+        "sha256_in_prefix": "331bcf0f9f635bd57c3384f2237260d074708b0975c700cfcbdb285f5f59ab1f",
+        "size_in_bytes": 25633
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/af.msg",
+        "path_type": "hardlink",
+        "sha256": "a1eaca556bc0cfbd219376287c72d9dbbfab76ecf9bf204fd02d40d341baf7da",
+        "sha256_in_prefix": "a1eaca556bc0cfbd219376287c72d9dbbfab76ecf9bf204fd02d40d341baf7da",
+        "size_in_bytes": 1038
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/af_za.msg",
+        "path_type": "hardlink",
+        "sha256": "1548988458bbf0dfccc23b7487cec0e9c64e4cc8e045723e50bec37c454a8c81",
+        "sha256_in_prefix": "1548988458bbf0dfccc23b7487cec0e9c64e4cc8e045723e50bec37c454a8c81",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ar.msg",
+        "path_type": "hardlink",
+        "sha256": "b69d0061a728d59f89ff8621312789cd9f540bf2e2ed297804d22f6278561d85",
+        "sha256_in_prefix": "b69d0061a728d59f89ff8621312789cd9f540bf2e2ed297804d22f6278561d85",
+        "size_in_bytes": 2018
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ar_in.msg",
+        "path_type": "hardlink",
+        "sha256": "2e04b96da002519d28125918a22ff2bb9659a668a7bcad34d85dddecec8dc0b4",
+        "sha256_in_prefix": "2e04b96da002519d28125918a22ff2bb9659a668a7bcad34d85dddecec8dc0b4",
+        "size_in_bytes": 265
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ar_jo.msg",
+        "path_type": "hardlink",
+        "sha256": "5adbb3d37c3369e5fc80d6a462c82598d5a22faef0e8df6b3148231d2c6a7f73",
+        "sha256_in_prefix": "5adbb3d37c3369e5fc80d6a462c82598d5a22faef0e8df6b3148231d2c6a7f73",
+        "size_in_bytes": 1851
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ar_lb.msg",
+        "path_type": "hardlink",
+        "sha256": "1fc13070cf661488e90fece84274c46b1f4cc7e1565eab8f829ccaa65108dfca",
+        "sha256_in_prefix": "1fc13070cf661488e90fece84274c46b1f4cc7e1565eab8f829ccaa65108dfca",
+        "size_in_bytes": 1851
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ar_sy.msg",
+        "path_type": "hardlink",
+        "sha256": "294f3e46c55453edad44567e1330f9b43e69a07fa0655b24dd2780a4490c1194",
+        "sha256_in_prefix": "294f3e46c55453edad44567e1330f9b43e69a07fa0655b24dd2780a4490c1194",
+        "size_in_bytes": 1851
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/be.msg",
+        "path_type": "hardlink",
+        "sha256": "a636a82c7d00ccdc0af2496043ffa320f17b0d48a1232708810d3bb1453e881e",
+        "sha256_in_prefix": "a636a82c7d00ccdc0af2496043ffa320f17b0d48a1232708810d3bb1453e881e",
+        "size_in_bytes": 2157
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/bg.msg",
+        "path_type": "hardlink",
+        "sha256": "cfe4e44a3a751f113847667ec9ea741e762bbde0d4284822cb337df0f92c1aca",
+        "sha256_in_prefix": "cfe4e44a3a751f113847667ec9ea741e762bbde0d4284822cb337df0f92c1aca",
+        "size_in_bytes": 1871
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/bn.msg",
+        "path_type": "hardlink",
+        "sha256": "890ea6521deb1b3c3913ccd92562f6360e064daee2e2b0356a6dd97a46264a1f",
+        "sha256_in_prefix": "890ea6521deb1b3c3913ccd92562f6360e064daee2e2b0356a6dd97a46264a1f",
+        "size_in_bytes": 2335
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/bn_in.msg",
+        "path_type": "hardlink",
+        "sha256": "b3d8a4632290b0f3da690e47c1fdf06a8b9e171a96e938afdb0dd52cf806ce54",
+        "sha256_in_prefix": "b3d8a4632290b0f3da690e47c1fdf06a8b9e171a96e938afdb0dd52cf806ce54",
+        "size_in_bytes": 265
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ca.msg",
+        "path_type": "hardlink",
+        "sha256": "3be295dcc8fcdc767fed0c68e3867359c18e7e57d7db6c07236b5bc572ad328e",
+        "sha256_in_prefix": "3be295dcc8fcdc767fed0c68e3867359c18e7e57d7db6c07236b5bc572ad328e",
+        "size_in_bytes": 1152
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/cs.msg",
+        "path_type": "hardlink",
+        "sha256": "afea12a16a6fa750ea610245133b90f178ba714848f89aec37429a3e7b06be1a",
+        "sha256_in_prefix": "afea12a16a6fa750ea610245133b90f178ba714848f89aec37429a3e7b06be1a",
+        "size_in_bytes": 1354
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/da.msg",
+        "path_type": "hardlink",
+        "sha256": "0d422a991bca13fe9033118691cfedab0f372222ebb0bc92baf8e914ee816b84",
+        "sha256_in_prefix": "0d422a991bca13fe9033118691cfedab0f372222ebb0bc92baf8e914ee816b84",
+        "size_in_bytes": 1208
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/de.msg",
+        "path_type": "hardlink",
+        "sha256": "4c27733502066e8391654d1d372f92bf0484c5a3821e121ae8aa5b99378c99ae",
+        "sha256_in_prefix": "4c27733502066e8391654d1d372f92bf0484c5a3821e121ae8aa5b99378c99ae",
+        "size_in_bytes": 1276
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/de_at.msg",
+        "path_type": "hardlink",
+        "sha256": "1c02d14140196623297f858e2eef00b4159e1c6fafe044ec65a48c9c24d46540",
+        "sha256_in_prefix": "1c02d14140196623297f858e2eef00b4159e1c6fafe044ec65a48c9c24d46540",
+        "size_in_bytes": 847
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/de_be.msg",
+        "path_type": "hardlink",
+        "sha256": "532845cd15ec821c1939d000c648694a64e8ca8f0c14bad5d79682cf991481ce",
+        "sha256_in_prefix": "532845cd15ec821c1939d000c648694a64e8ca8f0c14bad5d79682cf991481ce",
+        "size_in_bytes": 1276
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/el.msg",
+        "path_type": "hardlink",
+        "sha256": "8b23e0e2f0f319bb9a2dfdccdc565ff79a62fa85094811189b6bc41594232b6b",
+        "sha256_in_prefix": "8b23e0e2f0f319bb9a2dfdccdc565ff79a62fa85094811189b6bc41594232b6b",
+        "size_in_bytes": 2304
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_au.msg",
+        "path_type": "hardlink",
+        "sha256": "705c66c14b6de682ec7408eabdba0800c626629e64458971bc8a4cbd3d5db111",
+        "sha256_in_prefix": "705c66c14b6de682ec7408eabdba0800c626629e64458971bc8a4cbd3d5db111",
+        "size_in_bytes": 307
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_be.msg",
+        "path_type": "hardlink",
+        "sha256": "bc87754a253c1036e423fa553da182dbc56f62a13eda811d8cd9e8afa40404a6",
+        "sha256_in_prefix": "bc87754a253c1036e423fa553da182dbc56f62a13eda811d8cd9e8afa40404a6",
+        "size_in_bytes": 312
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_bw.msg",
+        "path_type": "hardlink",
+        "sha256": "ec48f18995d46f82b1cc71ea285174505a50e3ba2017bcce2d807149b7543fd0",
+        "sha256_in_prefix": "ec48f18995d46f82b1cc71ea285174505a50e3ba2017bcce2d807149b7543fd0",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_ca.msg",
+        "path_type": "hardlink",
+        "sha256": "3cf2d0937fd95264549cf5c768b898f01d4875a3eb4a85d457d758bc11dfec6e",
+        "sha256_in_prefix": "3cf2d0937fd95264549cf5c768b898f01d4875a3eb4a85d457d758bc11dfec6e",
+        "size_in_bytes": 295
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_gb.msg",
+        "path_type": "hardlink",
+        "sha256": "c2ce5b74f9e9c190b21c5df4106303b7b794481228fb9a57065b9c822a1059c3",
+        "sha256_in_prefix": "c2ce5b74f9e9c190b21c5df4106303b7b794481228fb9a57065b9c822a1059c3",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_hk.msg",
+        "path_type": "hardlink",
+        "sha256": "563450a38db6c6a1911bc04f4f55b816910b3e768b1465a69f9b3bd27292dbee",
+        "sha256_in_prefix": "563450a38db6c6a1911bc04f4f55b816910b3e768b1465a69f9b3bd27292dbee",
+        "size_in_bytes": 329
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_ie.msg",
+        "path_type": "hardlink",
+        "sha256": "9e0dcee86a03b7bdd831e0008868a9b874c506315bf01df3982ad3813fd3ba8e",
+        "sha256_in_prefix": "9e0dcee86a03b7bdd831e0008868a9b874c506315bf01df3982ad3813fd3ba8e",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_in.msg",
+        "path_type": "hardlink",
+        "sha256": "adea3a1ab8aa84237ddb2f276abdb96dcb4c51932e920d1a5e336904e1138664",
+        "sha256_in_prefix": "adea3a1ab8aa84237ddb2f276abdb96dcb4c51932e920d1a5e336904e1138664",
+        "size_in_bytes": 318
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_nz.msg",
+        "path_type": "hardlink",
+        "sha256": "ec305b7cb393421e6826d8f4fea749d3902eba53bfa488f2b463412f4070b9ed",
+        "sha256_in_prefix": "ec305b7cb393421e6826d8f4fea749d3902eba53bfa488f2b463412f4070b9ed",
+        "size_in_bytes": 307
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_ph.msg",
+        "path_type": "hardlink",
+        "sha256": "3a9c22b07906544c04f7a29b800fce87c09d7fdf5c251236925115cf251a3890",
+        "sha256_in_prefix": "3a9c22b07906544c04f7a29b800fce87c09d7fdf5c251236925115cf251a3890",
+        "size_in_bytes": 329
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_sg.msg",
+        "path_type": "hardlink",
+        "sha256": "d565679ae9aacbfe3b5273fe29bd46f46ffbb63c837d7925c11356d267f5ff82",
+        "sha256_in_prefix": "d565679ae9aacbfe3b5273fe29bd46f46ffbb63c837d7925c11356d267f5ff82",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_za.msg",
+        "path_type": "hardlink",
+        "sha256": "67c253e2a187aa814809418e5b7a21f3a1f9fb5073458a59d80290f58c6c1eb4",
+        "sha256_in_prefix": "67c253e2a187aa814809418e5b7a21f3a1f9fb5073458a59d80290f58c6c1eb4",
+        "size_in_bytes": 251
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/en_zw.msg",
+        "path_type": "hardlink",
+        "sha256": "6f4754ce29dfa4f0e7957923249151ce8277395d1af9f102d61b185f85899e4e",
+        "sha256_in_prefix": "6f4754ce29dfa4f0e7957923249151ce8277395d1af9f102d61b185f85899e4e",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/eo.msg",
+        "path_type": "hardlink",
+        "sha256": "98d52cab5ca65789d1dc37949b65baf0272ab87bccbb4d4982c3af380d5406ab",
+        "sha256_in_prefix": "98d52cab5ca65789d1dc37949b65baf0272ab87bccbb4d4982c3af380d5406ab",
+        "size_in_bytes": 1285
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es.msg",
+        "path_type": "hardlink",
+        "sha256": "e9a6fe8cce7c808487da505176984d02f7d644425934cedb10b521fe1e796202",
+        "sha256_in_prefix": "e9a6fe8cce7c808487da505176984d02f7d644425934cedb10b521fe1e796202",
+        "size_in_bytes": 1232
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_ar.msg",
+        "path_type": "hardlink",
+        "sha256": "b97dcea4fec3e14632b1511d8c4f9e5a157d97b4ebbc7c6ee100c3558cb2947f",
+        "sha256_in_prefix": "b97dcea4fec3e14632b1511d8c4f9e5a157d97b4ebbc7c6ee100c3558cb2947f",
+        "size_in_bytes": 248
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_bo.msg",
+        "path_type": "hardlink",
+        "sha256": "b47f55539db6f64304dea080d6f9a39165f1b9d4704dcba4c182dbd3aa31a11b",
+        "sha256_in_prefix": "b47f55539db6f64304dea080d6f9a39165f1b9d4704dcba4c182dbd3aa31a11b",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_cl.msg",
+        "path_type": "hardlink",
+        "sha256": "9d1a2a6eba673c6f6d964dbcddf228cb64978f282e70e494b60d74e16a1db9cb",
+        "sha256_in_prefix": "9d1a2a6eba673c6f6d964dbcddf228cb64978f282e70e494b60d74e16a1db9cb",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_co.msg",
+        "path_type": "hardlink",
+        "sha256": "5fac53acfb305c055afd0ba824742a78cb506046b26dac21c73f0bb60c2b889a",
+        "sha256_in_prefix": "5fac53acfb305c055afd0ba824742a78cb506046b26dac21c73f0bb60c2b889a",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_cr.msg",
+        "path_type": "hardlink",
+        "sha256": "a33dc22330d087b8567670b4915c334ff1741ee03f05d616cc801ecfda1d9e64",
+        "sha256_in_prefix": "a33dc22330d087b8567670b4915c334ff1741ee03f05d616cc801ecfda1d9e64",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_do.msg",
+        "path_type": "hardlink",
+        "sha256": "8dc2f857e91912ed46a94eb6b37dd6170ea7bcddcd41cb85c0926a74ee12fcc1",
+        "sha256_in_prefix": "8dc2f857e91912ed46a94eb6b37dd6170ea7bcddcd41cb85c0926a74ee12fcc1",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_ec.msg",
+        "path_type": "hardlink",
+        "sha256": "52ab5a6c9dd4f130a75c049b3af8f54b84071fc190374bccf5fa0e1f3b91eb21",
+        "sha256_in_prefix": "52ab5a6c9dd4f130a75c049b3af8f54b84071fc190374bccf5fa0e1f3b91eb21",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_gt.msg",
+        "path_type": "hardlink",
+        "sha256": "19b4d3025156c060a16328370a3fdb9f141298decfc8f97be606f6438fece2ee",
+        "sha256_in_prefix": "19b4d3025156c060a16328370a3fdb9f141298decfc8f97be606f6438fece2ee",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_hn.msg",
+        "path_type": "hardlink",
+        "sha256": "07873d4d59bb41000706a844859c73d26b1ff794058aa83cffca804981a24038",
+        "sha256_in_prefix": "07873d4d59bb41000706a844859c73d26b1ff794058aa83cffca804981a24038",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_mx.msg",
+        "path_type": "hardlink",
+        "sha256": "a0f57137d2c0abdc933e03cfb188f5632176c195ceadb9dc80d469c8dc6cedc6",
+        "sha256_in_prefix": "a0f57137d2c0abdc933e03cfb188f5632176c195ceadb9dc80d469c8dc6cedc6",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_ni.msg",
+        "path_type": "hardlink",
+        "sha256": "6250663da1378e54bedcef206583d212bc0d61d04d070495238d33715bb20cae",
+        "sha256_in_prefix": "6250663da1378e54bedcef206583d212bc0d61d04d070495238d33715bb20cae",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_pa.msg",
+        "path_type": "hardlink",
+        "sha256": "ebb661c1c09e7d4f6fbcc4b2dad0f41442b1ffdd27f003abdc0375dd316e57d7",
+        "sha256_in_prefix": "ebb661c1c09e7d4f6fbcc4b2dad0f41442b1ffdd27f003abdc0375dd316e57d7",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_pe.msg",
+        "path_type": "hardlink",
+        "sha256": "90c130b66958cf63cb3ddd2c633e58444357dbab44c56831dd794cbd2eb1aed0",
+        "sha256_in_prefix": "90c130b66958cf63cb3ddd2c633e58444357dbab44c56831dd794cbd2eb1aed0",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_pr.msg",
+        "path_type": "hardlink",
+        "sha256": "f790e8e48dc079dcd7deb58170561006a31294f7e4acbf9cf2abfa3db9e3fa9e",
+        "sha256_in_prefix": "f790e8e48dc079dcd7deb58170561006a31294f7e4acbf9cf2abfa3db9e3fa9e",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_py.msg",
+        "path_type": "hardlink",
+        "sha256": "70263f7eb22822dfee8849b7ac4418ed9331275a71e77236b59226396505cdff",
+        "sha256_in_prefix": "70263f7eb22822dfee8849b7ac4418ed9331275a71e77236b59226396505cdff",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_sv.msg",
+        "path_type": "hardlink",
+        "sha256": "26a38b3745c95673d21babb987f1d41ee08dda945c670f5432ba0ce6f893c0e9",
+        "sha256_in_prefix": "26a38b3745c95673d21babb987f1d41ee08dda945c670f5432ba0ce6f893c0e9",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_uy.msg",
+        "path_type": "hardlink",
+        "sha256": "1291b58810739ea0651493dd7887f5ee3e14bdb806e06dd4bb8ae2520c742eda",
+        "sha256_in_prefix": "1291b58810739ea0651493dd7887f5ee3e14bdb806e06dd4bb8ae2520c742eda",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/es_ve.msg",
+        "path_type": "hardlink",
+        "sha256": "91191517403c712299919f9c797f952502e33cb6961d1dbee3a7c9e8d2b170b9",
+        "sha256_in_prefix": "91191517403c712299919f9c797f952502e33cb6961d1dbee3a7c9e8d2b170b9",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/et.msg",
+        "path_type": "hardlink",
+        "sha256": "4bee224c21b0483cff39be145c671aa20cb7872c8727fd918c0e8eca2bbeb172",
+        "sha256_in_prefix": "4bee224c21b0483cff39be145c671aa20cb7872c8727fd918c0e8eca2bbeb172",
+        "size_in_bytes": 1258
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/eu.msg",
+        "path_type": "hardlink",
+        "sha256": "6889b57d29b670c6cfb7b5a3f2f1749d12c802e8e9629014d06ce23c034c7ef1",
+        "sha256_in_prefix": "6889b57d29b670c6cfb7b5a3f2f1749d12c802e8e9629014d06ce23c034c7ef1",
+        "size_in_bytes": 1032
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/eu_es.msg",
+        "path_type": "hardlink",
+        "sha256": "d45cc432e5743e6cec34e9a1e0f91a9d5c315cda409e0826b51ad9d908479eb6",
+        "sha256_in_prefix": "d45cc432e5743e6cec34e9a1e0f91a9d5c315cda409e0826b51ad9d908479eb6",
+        "size_in_bytes": 294
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fa.msg",
+        "path_type": "hardlink",
+        "sha256": "86898728b275288693b200568dc927c3ff5b9050690876c4441a8339dae06386",
+        "sha256_in_prefix": "86898728b275288693b200568dc927c3ff5b9050690876c4441a8339dae06386",
+        "size_in_bytes": 1711
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fa_in.msg",
+        "path_type": "hardlink",
+        "sha256": "6b56545c1ae1de53bc2389bb7ae59f115bade24f907e384e079491dc77d6541d",
+        "sha256_in_prefix": "6b56545c1ae1de53bc2389bb7ae59f115bade24f907e384e079491dc77d6541d",
+        "size_in_bytes": 2009
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fa_ir.msg",
+        "path_type": "hardlink",
+        "sha256": "3d9779c27e8960143d00961f6e82124120fd47b7f3cb82db3df21cdd9090c707",
+        "sha256_in_prefix": "3d9779c27e8960143d00961f6e82124120fd47b7f3cb82db3df21cdd9090c707",
+        "size_in_bytes": 426
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fi.msg",
+        "path_type": "hardlink",
+        "sha256": "9929a6b7139bd7e0f29487f7888a83e4c4f5e9ce0352738cfca94ee2ddf3bd6b",
+        "sha256_in_prefix": "9929a6b7139bd7e0f29487f7888a83e4c4f5e9ce0352738cfca94ee2ddf3bd6b",
+        "size_in_bytes": 1195
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fo.msg",
+        "path_type": "hardlink",
+        "sha256": "2ec9b03469fa38b260915c93318f446ea5e12b9090bd441936b57552eba1e3c9",
+        "sha256_in_prefix": "2ec9b03469fa38b260915c93318f446ea5e12b9090bd441936b57552eba1e3c9",
+        "size_in_bytes": 1033
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fo_fo.msg",
+        "path_type": "hardlink",
+        "sha256": "c3dccf5e5904c24d4ad9aaa36160a78f5397a7452510c0c0e61de4de863305cb",
+        "sha256_in_prefix": "c3dccf5e5904c24d4ad9aaa36160a78f5397a7452510c0c0e61de4de863305cb",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fr.msg",
+        "path_type": "hardlink",
+        "sha256": "96b1e1e12cd13a56722ebf27d362c70b467342fa1282a40b89fb16b5105a0480",
+        "sha256_in_prefix": "96b1e1e12cd13a56722ebf27d362c70b467342fa1282a40b89fb16b5105a0480",
+        "size_in_bytes": 1257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fr_be.msg",
+        "path_type": "hardlink",
+        "sha256": "aad828bcbb512fbd9902dcdd3812247a74913cc574deb07da95a7bbe74b1fe48",
+        "sha256_in_prefix": "aad828bcbb512fbd9902dcdd3812247a74913cc574deb07da95a7bbe74b1fe48",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fr_ca.msg",
+        "path_type": "hardlink",
+        "sha256": "0624df9a56723ddb89e59736c20a5837dea2206a789ebe7eef19ad287590ca45",
+        "sha256_in_prefix": "0624df9a56723ddb89e59736c20a5837dea2206a789ebe7eef19ad287590ca45",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/fr_ch.msg",
+        "path_type": "hardlink",
+        "sha256": "290ca6eb74baeac4e2420d0755d148849f89ee87e37860f25cbb7b8afa3edcbc",
+        "sha256_in_prefix": "290ca6eb74baeac4e2420d0755d148849f89ee87e37860f25cbb7b8afa3edcbc",
+        "size_in_bytes": 288
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ga.msg",
+        "path_type": "hardlink",
+        "sha256": "880806867acabd9b39e3029a5add26b690cc5709082d43b0959eba725ea07ab5",
+        "sha256_in_prefix": "880806867acabd9b39e3029a5add26b690cc5709082d43b0959eba725ea07ab5",
+        "size_in_bytes": 1188
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ga_ie.msg",
+        "path_type": "hardlink",
+        "sha256": "3f9615c617d3cdbc1e127b3efee785b0cb5e92e17b7dabac80da2beaf076362c",
+        "sha256_in_prefix": "3f9615c617d3cdbc1e127b3efee785b0cb5e92e17b7dabac80da2beaf076362c",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/gl.msg",
+        "path_type": "hardlink",
+        "sha256": "34d61b49dbf9584893051ffb458d6de9e7e2e7774ac0011f70c4dd4184eba81c",
+        "sha256_in_prefix": "34d61b49dbf9584893051ffb458d6de9e7e2e7774ac0011f70c4dd4184eba81c",
+        "size_in_bytes": 997
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/gl_es.msg",
+        "path_type": "hardlink",
+        "sha256": "b5688ca07d713227b713655877710258cd503617e8df79293a971649e3134f05",
+        "sha256_in_prefix": "b5688ca07d713227b713655877710258cd503617e8df79293a971649e3134f05",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/gv.msg",
+        "path_type": "hardlink",
+        "sha256": "404795f2c88d0038f9ed0b5120a251d26edf8b236e1b1698bc71acd4dc75ac45",
+        "sha256_in_prefix": "404795f2c88d0038f9ed0b5120a251d26edf8b236e1b1698bc71acd4dc75ac45",
+        "size_in_bytes": 1084
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/gv_gb.msg",
+        "path_type": "hardlink",
+        "sha256": "86cabf3b9360c0e686cc4cbeb843e971c28bc6d35210ed378b54eb58cc41f3d5",
+        "sha256_in_prefix": "86cabf3b9360c0e686cc4cbeb843e971c28bc6d35210ed378b54eb58cc41f3d5",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/he.msg",
+        "path_type": "hardlink",
+        "sha256": "787da79af58872bf45ab09e3b6a920a4496b5bd8a4f3c7f010cf013ec2e8efe0",
+        "sha256_in_prefix": "787da79af58872bf45ab09e3b6a920a4496b5bd8a4f3c7f010cf013ec2e8efe0",
+        "size_in_bytes": 1990
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/hi.msg",
+        "path_type": "hardlink",
+        "sha256": "192f4a8e77e1627712f85533c9896ef6a040157c7bd56df3a4a7fa56ad6746c2",
+        "sha256_in_prefix": "192f4a8e77e1627712f85533c9896ef6a040157c7bd56df3a4a7fa56ad6746c2",
+        "size_in_bytes": 1777
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/hi_in.msg",
+        "path_type": "hardlink",
+        "sha256": "5a3bf0dd61bfb5a2bf75e96b11e0e3528ffab720a0bf1923853606f8caf0e76d",
+        "sha256_in_prefix": "5a3bf0dd61bfb5a2bf75e96b11e0e3528ffab720a0bf1923853606f8caf0e76d",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/hr.msg",
+        "path_type": "hardlink",
+        "sha256": "105a9180bc5d23738183374fa0ea8dd80484bf3947e1432e515bdc2913c017d9",
+        "sha256_in_prefix": "105a9180bc5d23738183374fa0ea8dd80484bf3947e1432e515bdc2913c017d9",
+        "size_in_bytes": 1171
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/hu.msg",
+        "path_type": "hardlink",
+        "sha256": "993475532f89e1ea7214adb265294040862305612d680cff01dd20615b731ccc",
+        "sha256_in_prefix": "993475532f89e1ea7214adb265294040862305612d680cff01dd20615b731ccc",
+        "size_in_bytes": 1381
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/id.msg",
+        "path_type": "hardlink",
+        "sha256": "41c0c3d3b4491e9b36e719466503efcd325175cb7824c4a5055cb113d347be0f",
+        "sha256_in_prefix": "41c0c3d3b4491e9b36e719466503efcd325175cb7824c4a5055cb113d347be0f",
+        "size_in_bytes": 961
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/id_id.msg",
+        "path_type": "hardlink",
+        "sha256": "ba7fc0c0452d3e482db6e19bdf512caced639ba72b92ed8f66d80b52fea11ac0",
+        "sha256_in_prefix": "ba7fc0c0452d3e482db6e19bdf512caced639ba72b92ed8f66d80b52fea11ac0",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/is.msg",
+        "path_type": "hardlink",
+        "sha256": "778be3d6bfe2dffb64ff1afb9ec8351a3343b314cf93a68e8f7fd1073ee122bb",
+        "sha256_in_prefix": "778be3d6bfe2dffb64ff1afb9ec8351a3343b314cf93a68e8f7fd1073ee122bb",
+        "size_in_bytes": 1305
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/it.msg",
+        "path_type": "hardlink",
+        "sha256": "1d72170b9f9028a237364f7cd7ea8b48bd4770e61922205ce862300103b13de5",
+        "sha256_in_prefix": "1d72170b9f9028a237364f7cd7ea8b48bd4770e61922205ce862300103b13de5",
+        "size_in_bytes": 1294
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/it_ch.msg",
+        "path_type": "hardlink",
+        "sha256": "24b5f303f5c7af6f63fdc23adb4d713087ae74b6d18c117d787af03374c5f57e",
+        "sha256_in_prefix": "24b5f303f5c7af6f63fdc23adb4d713087ae74b6d18c117d787af03374c5f57e",
+        "size_in_bytes": 250
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ja.msg",
+        "path_type": "hardlink",
+        "sha256": "2b6d15a191437f1b84fa7023e34153b61e6bf1de1452ea921e9ccbbe5d4beb1c",
+        "sha256_in_prefix": "2b6d15a191437f1b84fa7023e34153b61e6bf1de1452ea921e9ccbbe5d4beb1c",
+        "size_in_bytes": 1689
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/kl.msg",
+        "path_type": "hardlink",
+        "sha256": "96ff17f1cff976e4e204d3616d1efced4d0f907c5e6a0f04b4536cb4ad1190c9",
+        "sha256_in_prefix": "96ff17f1cff976e4e204d3616d1efced4d0f907c5e6a0f04b4536cb4ad1190c9",
+        "size_in_bytes": 1025
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/kl_gl.msg",
+        "path_type": "hardlink",
+        "sha256": "3027cfe9ebd2172cefc15c025786cad47a6e2894bf0474afc1b0c341e70202aa",
+        "sha256_in_prefix": "3027cfe9ebd2172cefc15c025786cad47a6e2894bf0474afc1b0c341e70202aa",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ko.msg",
+        "path_type": "hardlink",
+        "sha256": "ef6fb319c398eea79b3a951319f831f3b186d556565d17d738e5f9b4b77570f2",
+        "sha256_in_prefix": "ef6fb319c398eea79b3a951319f831f3b186d556565d17d738e5f9b4b77570f2",
+        "size_in_bytes": 1621
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ko_kr.msg",
+        "path_type": "hardlink",
+        "sha256": "4cac8fb43d290a63a4d3215f22228b358ab4fa174f08712dd6c5b64c5e485071",
+        "sha256_in_prefix": "4cac8fb43d290a63a4d3215f22228b358ab4fa174f08712dd6c5b64c5e485071",
+        "size_in_bytes": 354
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/kok.msg",
+        "path_type": "hardlink",
+        "sha256": "9d215e31a39fed45b3657144e5f73c942e59e500036ce16b1fff201fd6358595",
+        "sha256_in_prefix": "9d215e31a39fed45b3657144e5f73c942e59e500036ce16b1fff201fd6358595",
+        "size_in_bytes": 1997
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/kok_in.msg",
+        "path_type": "hardlink",
+        "sha256": "644f2b6d4ba27af14891b781def60f708a9f18fc2f73566649b631a6dea3ef09",
+        "sha256_in_prefix": "644f2b6d4ba27af14891b781def60f708a9f18fc2f73566649b631a6dea3ef09",
+        "size_in_bytes": 260
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/kw.msg",
+        "path_type": "hardlink",
+        "sha256": "eab468ac5bf1833d4f8cd658789413d4a46cad16b63fb9b906cff6dc9ea26251",
+        "sha256_in_prefix": "eab468ac5bf1833d4f8cd658789413d4a46cad16b63fb9b906cff6dc9ea26251",
+        "size_in_bytes": 1013
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/kw_gb.msg",
+        "path_type": "hardlink",
+        "sha256": "edac14d929d1c6559ec46e9b460f8f44a189b78fb915f2d641104549cbd94188",
+        "sha256_in_prefix": "edac14d929d1c6559ec46e9b460f8f44a189b78fb915f2d641104549cbd94188",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/lt.msg",
+        "path_type": "hardlink",
+        "sha256": "855b652fcc8066ba45c7dc8dbfd3807d1b4759ea8d71c523567f47bf445d1de6",
+        "sha256_in_prefix": "855b652fcc8066ba45c7dc8dbfd3807d1b4759ea8d71c523567f47bf445d1de6",
+        "size_in_bytes": 1307
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/lv.msg",
+        "path_type": "hardlink",
+        "sha256": "7e90d2008b220db19c796c7107ad69d263b8ac8c7bddfb879230699d978e9a0a",
+        "sha256_in_prefix": "7e90d2008b220db19c796c7107ad69d263b8ac8c7bddfb879230699d978e9a0a",
+        "size_in_bytes": 1271
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/mk.msg",
+        "path_type": "hardlink",
+        "sha256": "4c0eb07f0fcb36dd12a3f7edd6531616611abf62bf7705b5a37cc59098221d5d",
+        "sha256_in_prefix": "4c0eb07f0fcb36dd12a3f7edd6531616611abf62bf7705b5a37cc59098221d5d",
+        "size_in_bytes": 2157
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/mr.msg",
+        "path_type": "hardlink",
+        "sha256": "ae873bf5484eacbbe179913d43451be53378fa701b5d81594d052266b8a09af0",
+        "sha256_in_prefix": "ae873bf5484eacbbe179913d43451be53378fa701b5d81594d052266b8a09af0",
+        "size_in_bytes": 1846
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/mr_in.msg",
+        "path_type": "hardlink",
+        "sha256": "b7b1d379355a1d278e13ef557a887a662e84fb6a9b62b8e19a27927926270ef9",
+        "sha256_in_prefix": "b7b1d379355a1d278e13ef557a887a662e84fb6a9b62b8e19a27927926270ef9",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ms.msg",
+        "path_type": "hardlink",
+        "sha256": "970b2f3ecc04980fcc2f9531ca6ce2bf36bc12942cb614bf70313b4cb0508985",
+        "sha256_in_prefix": "970b2f3ecc04980fcc2f9531ca6ce2bf36bc12942cb614bf70313b4cb0508985",
+        "size_in_bytes": 957
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ms_my.msg",
+        "path_type": "hardlink",
+        "sha256": "f5b859d8dd2a2b5f756e39b0dfeb26b95878d2f54ba3ce46c56f0f26cf2b554b",
+        "sha256_in_prefix": "f5b859d8dd2a2b5f756e39b0dfeb26b95878d2f54ba3ce46c56f0f26cf2b554b",
+        "size_in_bytes": 265
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/mt.msg",
+        "path_type": "hardlink",
+        "sha256": "7dbc4e82d82fde8cdf522fa10e082289d46b0c1a4a7d7a5fa83ff116677f052b",
+        "sha256_in_prefix": "7dbc4e82d82fde8cdf522fa10e082289d46b0c1a4a7d7a5fa83ff116677f052b",
+        "size_in_bytes": 717
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/nb.msg",
+        "path_type": "hardlink",
+        "sha256": "534c5dacef12f818faf4ed806997a559f95d591f1b6236b0c30b07a107dd13f3",
+        "sha256_in_prefix": "534c5dacef12f818faf4ed806997a559f95d591f1b6236b0c30b07a107dd13f3",
+        "size_in_bytes": 1209
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/nl.msg",
+        "path_type": "hardlink",
+        "sha256": "9e2fe3851cf13ec79a9b10a09b01ceb0a26044ae0dc90a4e00be57745e854c79",
+        "sha256_in_prefix": "9e2fe3851cf13ec79a9b10a09b01ceb0a26044ae0dc90a4e00be57745e854c79",
+        "size_in_bytes": 1129
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/nl_be.msg",
+        "path_type": "hardlink",
+        "sha256": "77a69dd60d171b321512b14794e75a66ff753410c007997b310790d86e09b057",
+        "sha256_in_prefix": "77a69dd60d171b321512b14794e75a66ff753410c007997b310790d86e09b057",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/nn.msg",
+        "path_type": "hardlink",
+        "sha256": "06fa2d6d8c59d0b8eac2ede5ab0ddb8b6e095d1a023b1966fce3b65916fa14fb",
+        "sha256_in_prefix": "06fa2d6d8c59d0b8eac2ede5ab0ddb8b6e095d1a023b1966fce3b65916fa14fb",
+        "size_in_bytes": 1200
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/pl.msg",
+        "path_type": "hardlink",
+        "sha256": "61462c325db0065352d8155307f949869862a86cac67ad7bb6703f57a7fa2ff3",
+        "sha256_in_prefix": "61462c325db0065352d8155307f949869862a86cac67ad7bb6703f57a7fa2ff3",
+        "size_in_bytes": 1263
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/pt.msg",
+        "path_type": "hardlink",
+        "sha256": "6f6eeeddcf232bdcb952592a144810ced44a1cbb4bcc2c062d5f98d441505380",
+        "sha256_in_prefix": "6f6eeeddcf232bdcb952592a144810ced44a1cbb4bcc2c062d5f98d441505380",
+        "size_in_bytes": 1177
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/pt_br.msg",
+        "path_type": "hardlink",
+        "sha256": "320be7d5b730091e6fa35f196314737261c8e154577dcf6ac8c2057d44394ad7",
+        "sha256_in_prefix": "320be7d5b730091e6fa35f196314737261c8e154577dcf6ac8c2057d44394ad7",
+        "size_in_bytes": 286
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ro.msg",
+        "path_type": "hardlink",
+        "sha256": "25ed6ac7a353e23b954b98611ae3b7e56bdcf2b0cb0db358253cfb8bebbb831c",
+        "sha256_in_prefix": "25ed6ac7a353e23b954b98611ae3b7e56bdcf2b0cb0db358253cfb8bebbb831c",
+        "size_in_bytes": 1224
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ru.msg",
+        "path_type": "hardlink",
+        "sha256": "bb35bb6f07baef72c329ec3e95d6527a2736070ee2ffe5de227e1ff0332390f8",
+        "sha256_in_prefix": "bb35bb6f07baef72c329ec3e95d6527a2736070ee2ffe5de227e1ff0332390f8",
+        "size_in_bytes": 2091
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ru_ua.msg",
+        "path_type": "hardlink",
+        "sha256": "13e4e79a0ed82034bade0cff8def5de1222f6968108ad710662bdb7daf36d7e1",
+        "sha256_in_prefix": "13e4e79a0ed82034bade0cff8def5de1222f6968108ad710662bdb7daf36d7e1",
+        "size_in_bytes": 248
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/sh.msg",
+        "path_type": "hardlink",
+        "sha256": "e65d6e5e837df0a2df0db77bce45334bbc27efff9023c37119e75d49932d9d6c",
+        "sha256_in_prefix": "e65d6e5e837df0a2df0db77bce45334bbc27efff9023c37119e75d49932d9d6c",
+        "size_in_bytes": 1212
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/sk.msg",
+        "path_type": "hardlink",
+        "sha256": "976813f6c53c9bebbf976b0f560fd7fc5e4ec4c574d7e1cd31f9a4056765cb7a",
+        "sha256_in_prefix": "976813f6c53c9bebbf976b0f560fd7fc5e4ec4c574d7e1cd31f9a4056765cb7a",
+        "size_in_bytes": 1255
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/sl.msg",
+        "path_type": "hardlink",
+        "sha256": "11a6264676dbed87e4f718075127e32e107854f35f141642454f484984084486",
+        "sha256_in_prefix": "11a6264676dbed87e4f718075127e32e107854f35f141642454f484984084486",
+        "size_in_bytes": 1216
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/sq.msg",
+        "path_type": "hardlink",
+        "sha256": "1f4efd78f6b45b65f73f09b2f52fc13c2a7c4138dcb7664804878d197b6ebdf9",
+        "sha256_in_prefix": "1f4efd78f6b45b65f73f09b2f52fc13c2a7c4138dcb7664804878d197b6ebdf9",
+        "size_in_bytes": 1321
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/sr.msg",
+        "path_type": "hardlink",
+        "sha256": "fa00a7b22c9941f6c2b893f22b703dcb159ca2f2e4005fd6a74a632aeb786bfa",
+        "sha256_in_prefix": "fa00a7b22c9941f6c2b893f22b703dcb159ca2f2e4005fd6a74a632aeb786bfa",
+        "size_in_bytes": 2087
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/sv.msg",
+        "path_type": "hardlink",
+        "sha256": "483916b51bd7e071e88f9ec36aaf3e08fea823991532f832de491c6c40b55a9f",
+        "sha256_in_prefix": "483916b51bd7e071e88f9ec36aaf3e08fea823991532f832de491c6c40b55a9f",
+        "size_in_bytes": 1219
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/sw.msg",
+        "path_type": "hardlink",
+        "sha256": "1da068c9aa02ef14a2440758c6040d632d96044a20ec501dbb9e40d8592e0e7f",
+        "sha256_in_prefix": "1da068c9aa02ef14a2440758c6040d632d96044a20ec501dbb9e40d8592e0e7f",
+        "size_in_bytes": 1040
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ta.msg",
+        "path_type": "hardlink",
+        "sha256": "aefdc4255890d5b3ffe5cee1b457b7d711283c2287aba644155c10956012f6c1",
+        "sha256_in_prefix": "aefdc4255890d5b3ffe5cee1b457b7d711283c2287aba644155c10956012f6c1",
+        "size_in_bytes": 1874
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/ta_in.msg",
+        "path_type": "hardlink",
+        "sha256": "4978a193076de56944236f7f1dcecacff739536dfb3dbefc1f7fe2b97a8aeaf4",
+        "sha256_in_prefix": "4978a193076de56944236f7f1dcecacff739536dfb3dbefc1f7fe2b97a8aeaf4",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/te.msg",
+        "path_type": "hardlink",
+        "sha256": "9e96c7123100234a7018533764502985a208f2eb3314f5b6332d46016725a63f",
+        "sha256_in_prefix": "9e96c7123100234a7018533764502985a208f2eb3314f5b6332d46016725a63f",
+        "size_in_bytes": 2149
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/te_in.msg",
+        "path_type": "hardlink",
+        "sha256": "b110feedda21eccefa624bef8e1476e9f221fb253880ac370967ae4d0237ca7a",
+        "sha256_in_prefix": "b110feedda21eccefa624bef8e1476e9f221fb253880ac370967ae4d0237ca7a",
+        "size_in_bytes": 419
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/th.msg",
+        "path_type": "hardlink",
+        "sha256": "48beaf693bf5b6eed15234db0d375b97e6d576a749e9048420c153e6cafc0259",
+        "sha256_in_prefix": "48beaf693bf5b6eed15234db0d375b97e6d576a749e9048420c153e6cafc0259",
+        "size_in_bytes": 2359
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/tr.msg",
+        "path_type": "hardlink",
+        "sha256": "4b85b345d6c43f7257c6849a60a492397fd5fd9d82df3a2252189d7a1eccbb64",
+        "sha256_in_prefix": "4b85b345d6c43f7257c6849a60a492397fd5fd9d82df3a2252189d7a1eccbb64",
+        "size_in_bytes": 1183
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/uk.msg",
+        "path_type": "hardlink",
+        "sha256": "7093da7e39ceb6d3f51eb6cf1cca2d7f3680ed7b8fe4a5f0ceceef6beb21ac77",
+        "sha256_in_prefix": "7093da7e39ceb6d3f51eb6cf1cca2d7f3680ed7b8fe4a5f0ceceef6beb21ac77",
+        "size_in_bytes": 2165
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/vi.msg",
+        "path_type": "hardlink",
+        "sha256": "e9b7aecd456f1d2288604c982b5ded0dcf71dca968c0b0eaff4ca16cc3b73ec2",
+        "sha256_in_prefix": "e9b7aecd456f1d2288604c982b5ded0dcf71dca968c0b0eaff4ca16cc3b73ec2",
+        "size_in_bytes": 1471
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/zh.msg",
+        "path_type": "hardlink",
+        "sha256": "eb247f5184a59414d3df7e3eca51f5998c248cfb27d2c02e62a7a30ab35197a7",
+        "sha256_in_prefix": "eb247f5184a59414d3df7e3eca51f5998c248cfb27d2c02e62a7a30ab35197a7",
+        "size_in_bytes": 3385
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/zh_cn.msg",
+        "path_type": "hardlink",
+        "sha256": "4c8a855700fefe8ee21b08030ff4159d8011ae50353f063229c42de6292475cf",
+        "sha256_in_prefix": "4c8a855700fefe8ee21b08030ff4159d8011ae50353f063229c42de6292475cf",
+        "size_in_bytes": 319
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/zh_hk.msg",
+        "path_type": "hardlink",
+        "sha256": "7e1c5bd9ec1a17bb851b0dcabd0dfa9ff9d64b89603d9d3fbeaac609172346ae",
+        "sha256_in_prefix": "7e1c5bd9ec1a17bb851b0dcabd0dfa9ff9d64b89603d9d3fbeaac609172346ae",
+        "size_in_bytes": 780
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/zh_sg.msg",
+        "path_type": "hardlink",
+        "sha256": "500546b3211d454659d845b4ab9aef226125100df40407c49530de17cdd4363f",
+        "sha256_in_prefix": "500546b3211d454659d845b4ab9aef226125100df40407c49530de17cdd4363f",
+        "size_in_bytes": 347
+      },
+      {
+        "_path": "tcl/tcl8.6/msgs/zh_tw.msg",
+        "path_type": "hardlink",
+        "sha256": "dba0584b8e1925b439f06e0bf0965e97afb7eb39e70e0e4c9b70769ebc5f996c",
+        "sha256_in_prefix": "dba0584b8e1925b439f06e0bf0965e97afb7eb39e70e0e4c9b70769ebc5f996c",
+        "size_in_bytes": 354
+      },
+      {
+        "_path": "tcl/tcl8.6/opt0.4/optparse.tcl",
+        "path_type": "hardlink",
+        "sha256": "67a157f1873d606b53dc4d894bd8e71f6b1a0dd66177b9513bd039b348b40349",
+        "sha256_in_prefix": "67a157f1873d606b53dc4d894bd8e71f6b1a0dd66177b9513bd039b348b40349",
+        "size_in_bytes": 33777
+      },
+      {
+        "_path": "tcl/tcl8.6/opt0.4/pkgIndex.tcl",
+        "path_type": "hardlink",
+        "sha256": "6a4abd2c519a745325c26fb23be7bbf95252d653a24806eb37fd4aa6a6479afe",
+        "sha256_in_prefix": "6a4abd2c519a745325c26fb23be7bbf95252d653a24806eb37fd4aa6a6479afe",
+        "size_in_bytes": 620
+      },
+      {
+        "_path": "tcl/tcl8.6/package.tcl",
+        "path_type": "hardlink",
+        "sha256": "f46ab61cdebe3aa45fa7e61a48930d64a0d0e7e94d04d6bf244f48c36cafe948",
+        "sha256_in_prefix": "f46ab61cdebe3aa45fa7e61a48930d64a0d0e7e94d04d6bf244f48c36cafe948",
+        "size_in_bytes": 23995
+      },
+      {
+        "_path": "tcl/tcl8.6/parray.tcl",
+        "path_type": "hardlink",
+        "sha256": "e269029c8263e3cbc1920c3604ecdcf15edccb208a0d68f9eb42b73954d620c0",
+        "sha256_in_prefix": "e269029c8263e3cbc1920c3604ecdcf15edccb208a0d68f9eb42b73954d620c0",
+        "size_in_bytes": 844
+      },
+      {
+        "_path": "tcl/tcl8.6/safe.tcl",
+        "path_type": "hardlink",
+        "sha256": "c21dce3ab31893118bbed01e559070f1d3541877fee331bd45f5bf4300ed9654",
+        "sha256_in_prefix": "c21dce3ab31893118bbed01e559070f1d3541877fee331bd45f5bf4300ed9654",
+        "size_in_bytes": 42223
+      },
+      {
+        "_path": "tcl/tcl8.6/tclIndex",
+        "path_type": "hardlink",
+        "sha256": "ddf7e42def37888ad0a564aa4f8ca95f4eec942cebebfca851d35515104d5c89",
+        "sha256_in_prefix": "ddf7e42def37888ad0a564aa4f8ca95f4eec942cebebfca851d35515104d5c89",
+        "size_in_bytes": 5617
+      },
+      {
+        "_path": "tcl/tcl8.6/tm.tcl",
+        "path_type": "hardlink",
+        "sha256": "4b7ed9fd2363d6876092db3f720cbddf97e72b86b519403539ba96e1c815ed8f",
+        "sha256_in_prefix": "4b7ed9fd2363d6876092db3f720cbddf97e72b86b519403539ba96e1c815ed8f",
+        "size_in_bytes": 12204
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Abidjan",
+        "path_type": "hardlink",
+        "sha256": "7213997bb9cf9d384a7002b8c8efef25c01aba6083d9835a16d583d5dcee40a0",
+        "sha256_in_prefix": "7213997bb9cf9d384a7002b8c8efef25c01aba6083d9835a16d583d5dcee40a0",
+        "size_in_bytes": 147
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Accra",
+        "path_type": "hardlink",
+        "sha256": "6040827afed8cef45f252fbd7e3e862c0b5e9d06c1c98c58bad61dfe67bd57cc",
+        "sha256_in_prefix": "6040827afed8cef45f252fbd7e3e862c0b5e9d06c1c98c58bad61dfe67bd57cc",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Addis_Ababa",
+        "path_type": "hardlink",
+        "sha256": "e11fd8ad8572b684333810cfdc23b92e1acf619875866985e288d92f8277d07f",
+        "sha256_in_prefix": "e11fd8ad8572b684333810cfdc23b92e1acf619875866985e288d92f8277d07f",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Algiers",
+        "path_type": "hardlink",
+        "sha256": "e6874647561ce1c5fd1f650c9b167f77ac5b24fd2026046399a9043cf998e5c4",
+        "sha256_in_prefix": "e6874647561ce1c5fd1f650c9b167f77ac5b24fd2026046399a9043cf998e5c4",
+        "size_in_bytes": 1080
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Asmara",
+        "path_type": "hardlink",
+        "sha256": "064eb7f9a1fa05a317c6bdca6b102bc1560d980758f9e4ddb010c9e7dc068ecb",
+        "sha256_in_prefix": "064eb7f9a1fa05a317c6bdca6b102bc1560d980758f9e4ddb010c9e7dc068ecb",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Asmera",
+        "path_type": "hardlink",
+        "sha256": "76939852a98ea7bf156d0ac18b434cc610daf5232322c0fbb066cd52c5b72af7",
+        "sha256_in_prefix": "76939852a98ea7bf156d0ac18b434cc610daf5232322c0fbb066cd52c5b72af7",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Bamako",
+        "path_type": "hardlink",
+        "sha256": "f6d1ba22115a6565b6d6abeb578f001ddb41e673c422c8ea70d0df77b24115f6",
+        "sha256_in_prefix": "f6d1ba22115a6565b6d6abeb578f001ddb41e673c422c8ea70d0df77b24115f6",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Bangui",
+        "path_type": "hardlink",
+        "sha256": "5047a507d22b68c9349eb6a48c41c80db4c69f98f99c6574059dea87178e36c0",
+        "sha256_in_prefix": "5047a507d22b68c9349eb6a48c41c80db4c69f98f99c6574059dea87178e36c0",
+        "size_in_bytes": 178
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Banjul",
+        "path_type": "hardlink",
+        "sha256": "77e610a02ccece3045b09d07a9be6100f5aa9c3c2aeb543535c9ae941194f4e4",
+        "sha256_in_prefix": "77e610a02ccece3045b09d07a9be6100f5aa9c3c2aeb543535c9ae941194f4e4",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Bissau",
+        "path_type": "hardlink",
+        "sha256": "2a870e534de67713c27f2f3b9bf26fa7498c240cf633988ce76dbdac5b69214d",
+        "sha256_in_prefix": "2a870e534de67713c27f2f3b9bf26fa7498c240cf633988ce76dbdac5b69214d",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Blantyre",
+        "path_type": "hardlink",
+        "sha256": "8f700409b8eee33ace5f050414971ffee0270949842e58e9299bb5cd6ccf34de",
+        "sha256_in_prefix": "8f700409b8eee33ace5f050414971ffee0270949842e58e9299bb5cd6ccf34de",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Brazzaville",
+        "path_type": "hardlink",
+        "sha256": "596db2d64cdd6250642cb65514d5bcb52f3e3ea83f50d8915d9d4fdea008f440",
+        "sha256_in_prefix": "596db2d64cdd6250642cb65514d5bcb52f3e3ea83f50d8915d9d4fdea008f440",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Bujumbura",
+        "path_type": "hardlink",
+        "sha256": "9a15867255b43a954ca60da11660f157553aab6a15c50acd49d182276e0cf4cc",
+        "sha256_in_prefix": "9a15867255b43a954ca60da11660f157553aab6a15c50acd49d182276e0cf4cc",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Cairo",
+        "path_type": "hardlink",
+        "sha256": "8698b0a53d858aea7c495edf759ef0e6c63f7e07a256599393dec7b7a7413734",
+        "sha256_in_prefix": "8698b0a53d858aea7c495edf759ef0e6c63f7e07a256599393dec7b7a7413734",
+        "size_in_bytes": 3852
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Casablanca",
+        "path_type": "hardlink",
+        "sha256": "8776eedfdfee09c4c833593127cefac9c33e2487ab9bf4bf8c73e5e11b4e5613",
+        "sha256_in_prefix": "8776eedfdfee09c4c833593127cefac9c33e2487ab9bf4bf8c73e5e11b4e5613",
+        "size_in_bytes": 5532
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Ceuta",
+        "path_type": "hardlink",
+        "sha256": "8827f7311ede69a9679bdf2b7418dbf350a2fc8f973e8b1e1e4390d4d5c6d2e8",
+        "sha256_in_prefix": "8827f7311ede69a9679bdf2b7418dbf350a2fc8f973e8b1e1e4390d4d5c6d2e8",
+        "size_in_bytes": 7536
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Conakry",
+        "path_type": "hardlink",
+        "sha256": "3176c99fc45337cbce0cd516de4b02b8baa47d00e84f698122a2add57797984e",
+        "sha256_in_prefix": "3176c99fc45337cbce0cd516de4b02b8baa47d00e84f698122a2add57797984e",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Dakar",
+        "path_type": "hardlink",
+        "sha256": "d50f9732757b284bac75526f2cfa585df7f6974160827afb0ff66124c7cfd361",
+        "sha256_in_prefix": "d50f9732757b284bac75526f2cfa585df7f6974160827afb0ff66124c7cfd361",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Dar_es_Salaam",
+        "path_type": "hardlink",
+        "sha256": "ab69948637416219a3d458777990fa4568bebc89388884bbf129c0e1370a560b",
+        "sha256_in_prefix": "ab69948637416219a3d458777990fa4568bebc89388884bbf129c0e1370a560b",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Djibouti",
+        "path_type": "hardlink",
+        "sha256": "e7f7560ccd65d53c446adae7128a74d37e17dd0b907a2f2fd85322fb8707b497",
+        "sha256_in_prefix": "e7f7560ccd65d53c446adae7128a74d37e17dd0b907a2f2fd85322fb8707b497",
+        "size_in_bytes": 186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Douala",
+        "path_type": "hardlink",
+        "sha256": "fcf2dad148f4d2951320ea99730c56d5eb43d505f37416be4bad265ce2902706",
+        "sha256_in_prefix": "fcf2dad148f4d2951320ea99730c56d5eb43d505f37416be4bad265ce2902706",
+        "size_in_bytes": 178
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/El_Aaiun",
+        "path_type": "hardlink",
+        "sha256": "5fb102a95b3c004aab8371840b1a04ac352f48ff9e9eafdeaaf21960b0f3caa6",
+        "sha256_in_prefix": "5fb102a95b3c004aab8371840b1a04ac352f48ff9e9eafdeaaf21960b0f3caa6",
+        "size_in_bytes": 5235
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Freetown",
+        "path_type": "hardlink",
+        "sha256": "bc53a4d489f48f14c594c4b0e52079b34e043a5751bbc7df254a560352243575",
+        "sha256_in_prefix": "bc53a4d489f48f14c594c4b0e52079b34e043a5751bbc7df254a560352243575",
+        "size_in_bytes": 186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Gaborone",
+        "path_type": "hardlink",
+        "sha256": "653af88955c4418d973e2f8681a99552eb7be95bca64c736072f488462f7b373",
+        "sha256_in_prefix": "653af88955c4418d973e2f8681a99552eb7be95bca64c736072f488462f7b373",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Harare",
+        "path_type": "hardlink",
+        "sha256": "06b82c524585192e0e8fc69dcc1cf86183a8c5ef404645dc413fcf3f8c16b0ab",
+        "sha256_in_prefix": "06b82c524585192e0e8fc69dcc1cf86183a8c5ef404645dc413fcf3f8c16b0ab",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Johannesburg",
+        "path_type": "hardlink",
+        "sha256": "5eef6475e1312051037fcae3354e32dc0910be7a5116b71f8ccbe1cca08d3f1c",
+        "sha256_in_prefix": "5eef6475e1312051037fcae3354e32dc0910be7a5116b71f8ccbe1cca08d3f1c",
+        "size_in_bytes": 309
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Juba",
+        "path_type": "hardlink",
+        "sha256": "f2646e15488abf2e960759cefe5705416e71da71bb8407b26196244fd1a3394f",
+        "sha256_in_prefix": "f2646e15488abf2e960759cefe5705416e71da71bb8407b26196244fd1a3394f",
+        "size_in_bytes": 1127
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Kampala",
+        "path_type": "hardlink",
+        "sha256": "8ea3028ce2b025f0c457dc8f7601279ca5af565a88b9fe80208f9f1030f2b0d0",
+        "sha256_in_prefix": "8ea3028ce2b025f0c457dc8f7601279ca5af565a88b9fe80208f9f1030f2b0d0",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Khartoum",
+        "path_type": "hardlink",
+        "sha256": "f475db8a857a46b310b12c21d6a9bc6ca9ff2960da429a9d57fa375f9439e13b",
+        "sha256_in_prefix": "f475db8a857a46b310b12c21d6a9bc6ca9ff2960da429a9d57fa375f9439e13b",
+        "size_in_bytes": 1131
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Kigali",
+        "path_type": "hardlink",
+        "sha256": "73feb807006897b4b485cb82394867444e890265efe960ec66d6c0e325da9372",
+        "sha256_in_prefix": "73feb807006897b4b485cb82394867444e890265efe960ec66d6c0e325da9372",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Kinshasa",
+        "path_type": "hardlink",
+        "sha256": "611375c4901ad6c4844c2bb7d02fb17f34996f49e642546a6784d6f0b28530cc",
+        "sha256_in_prefix": "611375c4901ad6c4844c2bb7d02fb17f34996f49e642546a6784d6f0b28530cc",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Lagos",
+        "path_type": "hardlink",
+        "sha256": "dcc9f52f539a67dfd7abafde072acdae2b67754c559c8a5fe61979f5a286a066",
+        "sha256_in_prefix": "dcc9f52f539a67dfd7abafde072acdae2b67754c559c8a5fe61979f5a286a066",
+        "size_in_bytes": 235
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Libreville",
+        "path_type": "hardlink",
+        "sha256": "ab3e797548c7663cf9aba7fe163635ff7cab9e6cb61fa1644c0f7b4b5cce8b99",
+        "sha256_in_prefix": "ab3e797548c7663cf9aba7fe163635ff7cab9e6cb61fa1644c0f7b4b5cce8b99",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Lome",
+        "path_type": "hardlink",
+        "sha256": "eaca9124f17e5b11f27d11fa6141d19eb3ac23e155e155b73467bdaa3bc99aa7",
+        "sha256_in_prefix": "eaca9124f17e5b11f27d11fa6141d19eb3ac23e155e155b73467bdaa3bc99aa7",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Luanda",
+        "path_type": "hardlink",
+        "sha256": "4c2fd1e44dfaaf0c0dd2eb56b84b538f1e2d84b301ab2cfb8ee7759783501444",
+        "sha256_in_prefix": "4c2fd1e44dfaaf0c0dd2eb56b84b538f1e2d84b301ab2cfb8ee7759783501444",
+        "size_in_bytes": 178
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Lubumbashi",
+        "path_type": "hardlink",
+        "sha256": "24384eec359fd24d181aaef3c017e3c345490a8d352b29d19b1b143a29a811c2",
+        "sha256_in_prefix": "24384eec359fd24d181aaef3c017e3c345490a8d352b29d19b1b143a29a811c2",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Lusaka",
+        "path_type": "hardlink",
+        "sha256": "b00801a7279741434d9c2d7ec7322dd93b85ea4f5c9976ab3a43f0ab142e1553",
+        "sha256_in_prefix": "b00801a7279741434d9c2d7ec7322dd93b85ea4f5c9976ab3a43f0ab142e1553",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Malabo",
+        "path_type": "hardlink",
+        "sha256": "35d56effe9e7e60f17b32bd30486e566b635f0ae7a8948d77395b8e6332e26f1",
+        "sha256_in_prefix": "35d56effe9e7e60f17b32bd30486e566b635f0ae7a8948d77395b8e6332e26f1",
+        "size_in_bytes": 178
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Maputo",
+        "path_type": "hardlink",
+        "sha256": "fe6b6a4be1b61f7f909a3f6137530dfe6d1754499a4d9b0d1ce4952fff0ae62d",
+        "sha256_in_prefix": "fe6b6a4be1b61f7f909a3f6137530dfe6d1754499a4d9b0d1ce4952fff0ae62d",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Maseru",
+        "path_type": "hardlink",
+        "sha256": "1d80fd86cb733d57d88ecd404e702f750b233ed0ccbfbfffeed1aad3b7f1cb04",
+        "sha256_in_prefix": "1d80fd86cb733d57d88ecd404e702f750b233ed0ccbfbfffeed1aad3b7f1cb04",
+        "size_in_bytes": 199
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Mbabane",
+        "path_type": "hardlink",
+        "sha256": "547197c09c1987350ae5720a4eec7e8d8f4b9f4a0559726e225e13c707f7c564",
+        "sha256_in_prefix": "547197c09c1987350ae5720a4eec7e8d8f4b9f4a0559726e225e13c707f7c564",
+        "size_in_bytes": 200
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Mogadishu",
+        "path_type": "hardlink",
+        "sha256": "25e221be49dec5547a74aeb91b0041859c59bc866987272a447ab2343d1cc30c",
+        "sha256_in_prefix": "25e221be49dec5547a74aeb91b0041859c59bc866987272a447ab2343d1cc30c",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Monrovia",
+        "path_type": "hardlink",
+        "sha256": "2bf0d90610211651127402680519b29ab50b15d344263d0c1a22edebe5e01e27",
+        "sha256_in_prefix": "2bf0d90610211651127402680519b29ab50b15d344263d0c1a22edebe5e01e27",
+        "size_in_bytes": 208
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Nairobi",
+        "path_type": "hardlink",
+        "sha256": "bd8e9765174431c0d403249d3e881c949c83966e9f8162552da88ae53132467b",
+        "sha256_in_prefix": "bd8e9765174431c0d403249d3e881c949c83966e9f8162552da88ae53132467b",
+        "size_in_bytes": 277
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Ndjamena",
+        "path_type": "hardlink",
+        "sha256": "9ada5f5afb25e823e1f0e8ad2489aaa1c09f01356634a9403670d7ab21ca2e2c",
+        "sha256_in_prefix": "9ada5f5afb25e823e1f0e8ad2489aaa1c09f01356634a9403670d7ab21ca2e2c",
+        "size_in_bytes": 208
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Niamey",
+        "path_type": "hardlink",
+        "sha256": "b517120ad8db3f21eab4e44a78001ee856eb4ea35852c54cca96d38887debcfa",
+        "sha256_in_prefix": "b517120ad8db3f21eab4e44a78001ee856eb4ea35852c54cca96d38887debcfa",
+        "size_in_bytes": 178
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Nouakchott",
+        "path_type": "hardlink",
+        "sha256": "64caf2bf9d45095df97f419714d5617cf6300acdb544b621dce1d594aa9b910c",
+        "sha256_in_prefix": "64caf2bf9d45095df97f419714d5617cf6300acdb544b621dce1d594aa9b910c",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Ouagadougou",
+        "path_type": "hardlink",
+        "sha256": "03b9c1fe350b5e9f6f333f9519fa394dcc562308d9388a903af3d3fecebdc762",
+        "sha256_in_prefix": "03b9c1fe350b5e9f6f333f9519fa394dcc562308d9388a903af3d3fecebdc762",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Porto-Novo",
+        "path_type": "hardlink",
+        "sha256": "8fb8692db9281ae2b087d704168bfd47d3d0901781fef65bfd62fcb213ba6b50",
+        "sha256_in_prefix": "8fb8692db9281ae2b087d704168bfd47d3d0901781fef65bfd62fcb213ba6b50",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Sao_Tome",
+        "path_type": "hardlink",
+        "sha256": "ba1d60df2b41320f92a123a714e17e576c89383526b96e0541a464c3fba415b7",
+        "sha256_in_prefix": "ba1d60df2b41320f92a123a714e17e576c89383526b96e0541a464c3fba415b7",
+        "size_in_bytes": 234
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Timbuktu",
+        "path_type": "hardlink",
+        "sha256": "9d8009acab019b32b1e87ab10e0ac3765abcabe8066318da8ca4905d41562f72",
+        "sha256_in_prefix": "9d8009acab019b32b1e87ab10e0ac3765abcabe8066318da8ca4905d41562f72",
+        "size_in_bytes": 186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Tripoli",
+        "path_type": "hardlink",
+        "sha256": "b447b6b1c351e77f22a2d77c0437f2bbb7d8bdfdfdc3d6285e0d260519cc7110",
+        "sha256_in_prefix": "b447b6b1c351e77f22a2d77c0437f2bbb7d8bdfdfdc3d6285e0d260519cc7110",
+        "size_in_bytes": 954
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Tunis",
+        "path_type": "hardlink",
+        "sha256": "0760d1028e733888e43e7f1e057217dc2b52786029fcec67b27eb69cc6a54938",
+        "sha256_in_prefix": "0760d1028e733888e43e7f1e057217dc2b52786029fcec67b27eb69cc6a54938",
+        "size_in_bytes": 1111
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Africa/Windhoek",
+        "path_type": "hardlink",
+        "sha256": "dfc3d1fc182b315b31d999bc103c264bd205eb16f971c8636003a71170d7bd7c",
+        "sha256_in_prefix": "dfc3d1fc182b315b31d999bc103c264bd205eb16f971c8636003a71170d7bd7c",
+        "size_in_bytes": 1649
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Adak",
+        "path_type": "hardlink",
+        "sha256": "77231d179260c08690a70aee6c2517e4b621ed4794d9aeea7040539f4ff05111",
+        "sha256_in_prefix": "77231d179260c08690a70aee6c2517e4b621ed4794d9aeea7040539f4ff05111",
+        "size_in_bytes": 8447
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Anchorage",
+        "path_type": "hardlink",
+        "sha256": "de7fbe2b3ed780c6b82099e1e249dd41f4452a3adb9dd807b1d0ec06049c2302",
+        "sha256_in_prefix": "de7fbe2b3ed780c6b82099e1e249dd41f4452a3adb9dd807b1d0ec06049c2302",
+        "size_in_bytes": 8685
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Anguilla",
+        "path_type": "hardlink",
+        "sha256": "f38610019c0a2c18ac71f5aa108b9647d9b5c01dcb55211afb8312308c41fe70",
+        "sha256_in_prefix": "f38610019c0a2c18ac71f5aa108b9647d9b5c01dcb55211afb8312308c41fe70",
+        "size_in_bytes": 202
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Antigua",
+        "path_type": "hardlink",
+        "sha256": "561e58e11dc5a86cae04b5cb40f43efcff9abc0c841fac094619e9c5e0b403f8",
+        "sha256_in_prefix": "561e58e11dc5a86cae04b5cb40f43efcff9abc0c841fac094619e9c5e0b403f8",
+        "size_in_bytes": 201
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Araguaina",
+        "path_type": "hardlink",
+        "sha256": "b1327cbec20a21e3ff873e28a2edfa271ee3a5c01933779300eabd6b185da010",
+        "sha256_in_prefix": "b1327cbec20a21e3ff873e28a2edfa271ee3a5c01933779300eabd6b185da010",
+        "size_in_bytes": 1782
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/Buenos_Aires",
+        "path_type": "hardlink",
+        "sha256": "bc86ac89121ec4aa302f6259ccc97effd7022dc6cee3b291c57da72b6ea0c558",
+        "sha256_in_prefix": "bc86ac89121ec4aa302f6259ccc97effd7022dc6cee3b291c57da72b6ea0c558",
+        "size_in_bytes": 2048
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/Catamarca",
+        "path_type": "hardlink",
+        "sha256": "a516bb0937977ef949d47b3c8675e30f1ca6c34f8bd298dcf6ebb943580d5317",
+        "sha256_in_prefix": "a516bb0937977ef949d47b3c8675e30f1ca6c34f8bd298dcf6ebb943580d5317",
+        "size_in_bytes": 2077
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/ComodRivadavia",
+        "path_type": "hardlink",
+        "sha256": "8ccd6fc77d55582938f1912b1ba66035882d1bfc18a797c631e5e89abfbf570b",
+        "sha256_in_prefix": "8ccd6fc77d55582938f1912b1ba66035882d1bfc18a797c631e5e89abfbf570b",
+        "size_in_bytes": 242
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/Cordoba",
+        "path_type": "hardlink",
+        "sha256": "fa75e274240a341c6bfe3539cfdc114d125aeaea3161d3c2409347cf8046042a",
+        "sha256_in_prefix": "fa75e274240a341c6bfe3539cfdc114d125aeaea3161d3c2409347cf8046042a",
+        "size_in_bytes": 2043
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/Jujuy",
+        "path_type": "hardlink",
+        "sha256": "43eb79abc03cbac661c563de1bc09d9dd855cbc72dd2b6467ea98f0f90421ba9",
+        "sha256_in_prefix": "43eb79abc03cbac661c563de1bc09d9dd855cbc72dd2b6467ea98f0f90421ba9",
+        "size_in_bytes": 2041
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/La_Rioja",
+        "path_type": "hardlink",
+        "sha256": "2b018b791e48269fa9eda12662ffec3e2dc33603a918e8b735b8d7d6beb3b3aa",
+        "sha256_in_prefix": "2b018b791e48269fa9eda12662ffec3e2dc33603a918e8b735b8d7d6beb3b3aa",
+        "size_in_bytes": 2106
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/Mendoza",
+        "path_type": "hardlink",
+        "sha256": "dc39400bbfd5bdddc174fe099194806fbfd3fc3aa20e670d67be0ac35fe97ad4",
+        "sha256_in_prefix": "dc39400bbfd5bdddc174fe099194806fbfd3fc3aa20e670d67be0ac35fe97ad4",
+        "size_in_bytes": 2077
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/Rio_Gallegos",
+        "path_type": "hardlink",
+        "sha256": "a05b6708deff0607396bfc6661c2287341c3432841ae353d94a67ac742b5fafa",
+        "sha256_in_prefix": "a05b6708deff0607396bfc6661c2287341c3432841ae353d94a67ac742b5fafa",
+        "size_in_bytes": 2080
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/Salta",
+        "path_type": "hardlink",
+        "sha256": "caefc60f2f36ef9ffe0c5921c3c392de1e95755683a96c1c4ec0ba2c242a4d84",
+        "sha256_in_prefix": "caefc60f2f36ef9ffe0c5921c3c392de1e95755683a96c1c4ec0ba2c242a4d84",
+        "size_in_bytes": 2011
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/San_Juan",
+        "path_type": "hardlink",
+        "sha256": "41b2c25e42146a76934b866061bb3245b8ada0ff4e1bfba6f8842a30bdd5c132",
+        "sha256_in_prefix": "41b2c25e42146a76934b866061bb3245b8ada0ff4e1bfba6f8842a30bdd5c132",
+        "size_in_bytes": 2106
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/San_Luis",
+        "path_type": "hardlink",
+        "sha256": "a43b35f25e54ef359d046e33281c0a978f0ee8811c93a6809f1f65750878bbb6",
+        "sha256_in_prefix": "a43b35f25e54ef359d046e33281c0a978f0ee8811c93a6809f1f65750878bbb6",
+        "size_in_bytes": 2081
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/Tucuman",
+        "path_type": "hardlink",
+        "sha256": "0f7db23e1280fc19a1fb716e09a9699ada2aae24084cad472b4c325cc9783ccf",
+        "sha256_in_prefix": "0f7db23e1280fc19a1fb716e09a9699ada2aae24084cad472b4c325cc9783ccf",
+        "size_in_bytes": 2105
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Argentina/Ushuaia",
+        "path_type": "hardlink",
+        "sha256": "10b6ff51314d8ee1d010187d8805c4e3d71b778bc6decb26e66193a5bb3e9ea2",
+        "sha256_in_prefix": "10b6ff51314d8ee1d010187d8805c4e3d71b778bc6decb26e66193a5bb3e9ea2",
+        "size_in_bytes": 2075
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Aruba",
+        "path_type": "hardlink",
+        "sha256": "7490cd66408b8a14c549278fe67dc3338fe9e458f423f01ccbea00b5e6f6cef6",
+        "sha256_in_prefix": "7490cd66408b8a14c549278fe67dc3338fe9e458f423f01ccbea00b5e6f6cef6",
+        "size_in_bytes": 199
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Asuncion",
+        "path_type": "hardlink",
+        "sha256": "eaefe21276ee60c7f876c1d65039999ac069339dcdb82a23fc9206c274510575",
+        "sha256_in_prefix": "eaefe21276ee60c7f876c1d65039999ac069339dcdb82a23fc9206c274510575",
+        "size_in_bytes": 7944
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Atikokan",
+        "path_type": "hardlink",
+        "sha256": "518beb6e54ae811f8c725ea8cc42787d48fc605a3476d6e7a00a1b5733cbd6ac",
+        "sha256_in_prefix": "518beb6e54ae811f8c725ea8cc42787d48fc605a3476d6e7a00a1b5733cbd6ac",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Atka",
+        "path_type": "hardlink",
+        "sha256": "1d6fee336e71fffb64874a830c976867c071ebf6b133c296b32f87e3e7d814c9",
+        "sha256_in_prefix": "1d6fee336e71fffb64874a830c976867c071ebf6b133c296b32f87e3e7d814c9",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Bahia",
+        "path_type": "hardlink",
+        "sha256": "64f1ec14f6b43ff10b564f839152e88df9262f0947d1db347557fa902f6fd48c",
+        "sha256_in_prefix": "64f1ec14f6b43ff10b564f839152e88df9262f0947d1db347557fa902f6fd48c",
+        "size_in_bytes": 2012
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Bahia_Banderas",
+        "path_type": "hardlink",
+        "sha256": "b24ae5fa20f5329644529f660eec8baa3b966f9730af58f1c21e94c02ae17228",
+        "sha256_in_prefix": "b24ae5fa20f5329644529f660eec8baa3b966f9730af58f1c21e94c02ae17228",
+        "size_in_bytes": 6847
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Barbados",
+        "path_type": "hardlink",
+        "sha256": "fd5e04136506c6543a9acdc890a30bcf0d561148e1063ec857e3913de1eba404",
+        "sha256_in_prefix": "fd5e04136506c6543a9acdc890a30bcf0d561148e1063ec857e3913de1eba404",
+        "size_in_bytes": 648
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Belem",
+        "path_type": "hardlink",
+        "sha256": "549625ccb30bd0e025bac47668ba3aa0cdd8569e5887e483c8d62b5b7302fa50",
+        "sha256_in_prefix": "549625ccb30bd0e025bac47668ba3aa0cdd8569e5887e483c8d62b5b7302fa50",
+        "size_in_bytes": 1031
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Belize",
+        "path_type": "hardlink",
+        "sha256": "e07f45264e28fd5aa54bd48cb701658509829cf989ec9bd79498d070a1ba270f",
+        "sha256_in_prefix": "e07f45264e28fd5aa54bd48cb701658509829cf989ec9bd79498d070a1ba270f",
+        "size_in_bytes": 3284
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Blanc-Sablon",
+        "path_type": "hardlink",
+        "sha256": "facd0a835d1f425cd323ee453ade231810b2d1cf6eba227ba1b50522ae3879f7",
+        "sha256_in_prefix": "facd0a835d1f425cd323ee453ade231810b2d1cf6eba227ba1b50522ae3879f7",
+        "size_in_bytes": 206
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Boa_Vista",
+        "path_type": "hardlink",
+        "sha256": "10592ea1cb0d02c06a61059ec601f70a706a5053ac923b9eed29388d5e71ef3a",
+        "sha256_in_prefix": "10592ea1cb0d02c06a61059ec601f70a706a5053ac923b9eed29388d5e71ef3a",
+        "size_in_bytes": 1199
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Bogota",
+        "path_type": "hardlink",
+        "sha256": "b6adc16815dc95e537548ca3572d7f93626a6d1dc390dd4cbabab5ab855bba30",
+        "sha256_in_prefix": "b6adc16815dc95e537548ca3572d7f93626a6d1dc390dd4cbabab5ab855bba30",
+        "size_in_bytes": 246
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Boise",
+        "path_type": "hardlink",
+        "sha256": "93af910cb2ad2203b71c1ad49d56df4a4a14d07f885afd4e755271f1372a517c",
+        "sha256_in_prefix": "93af910cb2ad2203b71c1ad49d56df4a4a14d07f885afd4e755271f1372a517c",
+        "size_in_bytes": 8605
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Buenos_Aires",
+        "path_type": "hardlink",
+        "sha256": "defc5c9da2d4d4146145a50d692a6bff698c3b0a1f19efd82ad0ee7678f39fcf",
+        "sha256_in_prefix": "defc5c9da2d4d4146145a50d692a6bff698c3b0a1f19efd82ad0ee7678f39fcf",
+        "size_in_bytes": 239
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Cambridge_Bay",
+        "path_type": "hardlink",
+        "sha256": "3e0506a54b562dbc3aa6889ddd39b327fe0b85c63b00f0b39d606921a0936a59",
+        "sha256_in_prefix": "3e0506a54b562dbc3aa6889ddd39b327fe0b85c63b00f0b39d606921a0936a59",
+        "size_in_bytes": 7739
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Campo_Grande",
+        "path_type": "hardlink",
+        "sha256": "6d5bd1355016b03edea58df98bec26281cd372725b2dcb60b4d748d2fb4346c8",
+        "sha256_in_prefix": "6d5bd1355016b03edea58df98bec26281cd372725b2dcb60b4d748d2fb4346c8",
+        "size_in_bytes": 2918
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Cancun",
+        "path_type": "hardlink",
+        "sha256": "fd6c370f82e5cfe374637e0e222e72570857ac3f85143beeef9c3d0e7a6c0d04",
+        "sha256_in_prefix": "fd6c370f82e5cfe374637e0e222e72570857ac3f85143beeef9c3d0e7a6c0d04",
+        "size_in_bytes": 1412
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Caracas",
+        "path_type": "hardlink",
+        "sha256": "d558c25f165e956e980aa8f554ab3bf24e91b51eadbd2b1065ef6dfda0e2f984",
+        "sha256_in_prefix": "d558c25f165e956e980aa8f554ab3bf24e91b51eadbd2b1065ef6dfda0e2f984",
+        "size_in_bytes": 284
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Catamarca",
+        "path_type": "hardlink",
+        "sha256": "37cd6bdaa6c6eedfac3288ca1c11f5cbbe8a17e5f2e790e7635a64b867afbd87",
+        "sha256_in_prefix": "37cd6bdaa6c6eedfac3288ca1c11f5cbbe8a17e5f2e790e7635a64b867afbd87",
+        "size_in_bytes": 227
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Cayenne",
+        "path_type": "hardlink",
+        "sha256": "873285f3e13cb68dd28eb109ecad8d260e11a9ff6df6a4e8e0d4c00b0182695b",
+        "sha256_in_prefix": "873285f3e13cb68dd28eb109ecad8d260e11a9ff6df6a4e8e0d4c00b0182695b",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Cayman",
+        "path_type": "hardlink",
+        "sha256": "c38c49ae1c3e67bd2118002dcfcc3c0efb6892fb9b0106908a9282c414d0bf2e",
+        "sha256_in_prefix": "c38c49ae1c3e67bd2118002dcfcc3c0efb6892fb9b0106908a9282c414d0bf2e",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Chicago",
+        "path_type": "hardlink",
+        "sha256": "c7707af88d650f90839e7258356e39d85228b33b6dbcc5c065c3d8733ae28cee",
+        "sha256_in_prefix": "c7707af88d650f90839e7258356e39d85228b33b6dbcc5c065c3d8733ae28cee",
+        "size_in_bytes": 11372
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Chihuahua",
+        "path_type": "hardlink",
+        "sha256": "a816dc1c4c2fb7509a50cb209d748dac27c5f858a2842d7e12b2ec620fea988b",
+        "sha256_in_prefix": "a816dc1c4c2fb7509a50cb209d748dac27c5f858a2842d7e12b2ec620fea988b",
+        "size_in_bytes": 6814
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Coral_Harbour",
+        "path_type": "hardlink",
+        "sha256": "c8cbf5a29cc1d0827390ca6e98b2efcf90743c6dd0eca143b300050dd4164041",
+        "sha256_in_prefix": "c8cbf5a29cc1d0827390ca6e98b2efcf90743c6dd0eca143b300050dd4164041",
+        "size_in_bytes": 192
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Cordoba",
+        "path_type": "hardlink",
+        "sha256": "28b84710eadef7ad5e7fa63ef519a9d93996d3bb91dd9018333de3ac4d8fb8dd",
+        "sha256_in_prefix": "28b84710eadef7ad5e7fa63ef519a9d93996d3bb91dd9018333de3ac4d8fb8dd",
+        "size_in_bytes": 219
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Costa_Rica",
+        "path_type": "hardlink",
+        "sha256": "e3061dc6fa9f869f013351a9fdf420448592d7f959c2b4404093432508146f7e",
+        "sha256_in_prefix": "e3061dc6fa9f869f013351a9fdf420448592d7f959c2b4404093432508146f7e",
+        "size_in_bytes": 431
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Creston",
+        "path_type": "hardlink",
+        "sha256": "a01ddb460420c8765ce8ef7a7d031abd7bdb17cfa548e7c3b8574c388aa21e17",
+        "sha256_in_prefix": "a01ddb460420c8765ce8ef7a7d031abd7bdb17cfa548e7c3b8574c388aa21e17",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Cuiaba",
+        "path_type": "hardlink",
+        "sha256": "2d8281cf3fd9e859c5206f781e264854fa876cb36562a08c6c01343c65f8a508",
+        "sha256_in_prefix": "2d8281cf3fd9e859c5206f781e264854fa876cb36562a08c6c01343c65f8a508",
+        "size_in_bytes": 2912
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Curacao",
+        "path_type": "hardlink",
+        "sha256": "accf08cf53c9431e226714df8bede3c91baf62d5bd7b98ca8b50d7258124d129",
+        "sha256_in_prefix": "accf08cf53c9431e226714df8bede3c91baf62d5bd7b98ca8b50d7258124d129",
+        "size_in_bytes": 201
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Danmarkshavn",
+        "path_type": "hardlink",
+        "sha256": "968c56f1d0106e1d92c7b094eef528b6ee1ffa3d7a18be2f2ba59178c2c0f1e0",
+        "sha256_in_prefix": "968c56f1d0106e1d92c7b094eef528b6ee1ffa3d7a18be2f2ba59178c2c0f1e0",
+        "size_in_bytes": 1128
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Dawson",
+        "path_type": "hardlink",
+        "sha256": "30e875343c81c8de473e6313a27c55315f38e7ccdbd2cee5783ec54d269d5807",
+        "sha256_in_prefix": "30e875343c81c8de473e6313a27c55315f38e7ccdbd2cee5783ec54d269d5807",
+        "size_in_bytes": 2967
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Dawson_Creek",
+        "path_type": "hardlink",
+        "sha256": "540804becdeab92340ef02d32a62bfd550b71a3db8d829be426ee4d210004643",
+        "sha256_in_prefix": "540804becdeab92340ef02d32a62bfd550b71a3db8d829be426ee4d210004643",
+        "size_in_bytes": 1940
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Denver",
+        "path_type": "hardlink",
+        "sha256": "3fe2ee8c05c5d6f268b58bd9fc3e3a845dea257473b29f7b3fb403e917448f3c",
+        "sha256_in_prefix": "3fe2ee8c05c5d6f268b58bd9fc3e3a845dea257473b29f7b3fb403e917448f3c",
+        "size_in_bytes": 8920
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Detroit",
+        "path_type": "hardlink",
+        "sha256": "84f6897b87d3978d30d35097b78c55434ce55eb65d6e488a391dfc3b3bb5a8fe",
+        "sha256_in_prefix": "84f6897b87d3978d30d35097b78c55434ce55eb65d6e488a391dfc3b3bb5a8fe",
+        "size_in_bytes": 8430
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Dominica",
+        "path_type": "hardlink",
+        "sha256": "3da98aa7d3085845779be8ed6c93ccbda92191f17ca67bbf779803e21da2abf3",
+        "sha256_in_prefix": "3da98aa7d3085845779be8ed6c93ccbda92191f17ca67bbf779803e21da2abf3",
+        "size_in_bytes": 202
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Edmonton",
+        "path_type": "hardlink",
+        "sha256": "026d51d73d30a3710288f440e0c337e44e3a14d0aa2d7b6c6e53af43fc72a90c",
+        "sha256_in_prefix": "026d51d73d30a3710288f440e0c337e44e3a14d0aa2d7b6c6e53af43fc72a90c",
+        "size_in_bytes": 8600
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Eirunepe",
+        "path_type": "hardlink",
+        "sha256": "48fc987e5999ea79f24797e0450fe4dab7cf320dfad7a47a8a1e037077ec42c9",
+        "sha256_in_prefix": "48fc987e5999ea79f24797e0450fe4dab7cf320dfad7a47a8a1e037077ec42c9",
+        "size_in_bytes": 1230
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/El_Salvador",
+        "path_type": "hardlink",
+        "sha256": "c02c6e79398553bd07bea0be4b7f0ebdd8bc821595909cffb49de4290a0d1d0f",
+        "sha256_in_prefix": "c02c6e79398553bd07bea0be4b7f0ebdd8bc821595909cffb49de4290a0d1d0f",
+        "size_in_bytes": 279
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Ensenada",
+        "path_type": "hardlink",
+        "sha256": "3e363bf82545f24cce8cfa6eec97ba6e1c2a7730b2a9ce6c48f784821d308a5d",
+        "sha256_in_prefix": "3e363bf82545f24cce8cfa6eec97ba6e1c2a7730b2a9ce6c48f784821d308a5d",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Fort_Nelson",
+        "path_type": "hardlink",
+        "sha256": "ab15023807e7c7d1026c9970d190f1b405d48952464025242c2bb6c6bbb8391a",
+        "sha256_in_prefix": "ab15023807e7c7d1026c9970d190f1b405d48952464025242c2bb6c6bbb8391a",
+        "size_in_bytes": 4578
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Fort_Wayne",
+        "path_type": "hardlink",
+        "sha256": "c8948616262cf6990739343abbbd237e572db49310099e21dd8f9e317f7d11b3",
+        "sha256_in_prefix": "c8948616262cf6990739343abbbd237e572db49310099e21dd8f9e317f7d11b3",
+        "size_in_bytes": 231
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Fortaleza",
+        "path_type": "hardlink",
+        "sha256": "c0a836bdaf07f0376b7b0833a0ab3d52ba6e3e1d6f95e247e1ad351cd1096066",
+        "sha256_in_prefix": "c0a836bdaf07f0376b7b0833a0ab3d52ba6e3e1d6f95e247e1ad351cd1096066",
+        "size_in_bytes": 1423
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Glace_Bay",
+        "path_type": "hardlink",
+        "sha256": "58c207cbd9de7a7bb15e48a62cea9f15da184b945133dee88eff29fd8b66b29e",
+        "sha256_in_prefix": "58c207cbd9de7a7bb15e48a62cea9f15da184b945133dee88eff29fd8b66b29e",
+        "size_in_bytes": 8372
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Godthab",
+        "path_type": "hardlink",
+        "sha256": "5fb2cfba25ce2f49d4c3911aff8e7e1ff84efc2d01f5783772e88246bfbc56ac",
+        "sha256_in_prefix": "5fb2cfba25ce2f49d4c3911aff8e7e1ff84efc2d01f5783772e88246bfbc56ac",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Goose_Bay",
+        "path_type": "hardlink",
+        "sha256": "52d2478289682bf95bfb93d64d679e888c9d23c0f68dfff7e6e34bfc44b3d892",
+        "sha256_in_prefix": "52d2478289682bf95bfb93d64d679e888c9d23c0f68dfff7e6e34bfc44b3d892",
+        "size_in_bytes": 10353
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Grand_Turk",
+        "path_type": "hardlink",
+        "sha256": "560b39485ced4c2a0e85a66eb875331e5879104187d92cb7f05c2f635e34ac99",
+        "sha256_in_prefix": "560b39485ced4c2a0e85a66eb875331e5879104187d92cb7f05c2f635e34ac99",
+        "size_in_bytes": 7522
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Grenada",
+        "path_type": "hardlink",
+        "sha256": "ebed070e8e67c5f12ff6e03fe508be90789f17c793dfe61237b4045b8222580f",
+        "sha256_in_prefix": "ebed070e8e67c5f12ff6e03fe508be90789f17c793dfe61237b4045b8222580f",
+        "size_in_bytes": 201
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Guadeloupe",
+        "path_type": "hardlink",
+        "sha256": "6cb1930532831d12057fcb484c60db64a60a4f6d8195dafd464826923116a294",
+        "sha256_in_prefix": "6cb1930532831d12057fcb484c60db64a60a4f6d8195dafd464826923116a294",
+        "size_in_bytes": 204
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Guatemala",
+        "path_type": "hardlink",
+        "sha256": "14f6a98d602f3648c816b110f3a0ba375e1ffe8fa06beeab419dc1abfa6edcaf",
+        "sha256_in_prefix": "14f6a98d602f3648c816b110f3a0ba375e1ffe8fa06beeab419dc1abfa6edcaf",
+        "size_in_bytes": 399
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Guayaquil",
+        "path_type": "hardlink",
+        "sha256": "6806aa5814bdc679c6ef653c518d2699114be71d973f49c0864f622038dc2048",
+        "sha256_in_prefix": "6806aa5814bdc679c6ef653c518d2699114be71d973f49c0864f622038dc2048",
+        "size_in_bytes": 249
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Guyana",
+        "path_type": "hardlink",
+        "sha256": "4078d2e361d04a66f22f652e3810cdf7f630cf89399b47e4ec7b1d32b400fd85",
+        "sha256_in_prefix": "4078d2e361d04a66f22f652e3810cdf7f630cf89399b47e4ec7b1d32b400fd85",
+        "size_in_bytes": 248
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Halifax",
+        "path_type": "hardlink",
+        "sha256": "01e11c7b07925d05e9e1876c310a2b87e0e80ef115d062225212e472b7a964f1",
+        "sha256_in_prefix": "01e11c7b07925d05e9e1876c310a2b87e0e80ef115d062225212e472b7a964f1",
+        "size_in_bytes": 11124
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Havana",
+        "path_type": "hardlink",
+        "sha256": "96b62bfbf0c05cf970245597c691f89ebf631175796459642a85287f131d0215",
+        "sha256_in_prefix": "96b62bfbf0c05cf970245597c691f89ebf631175796459642a85287f131d0215",
+        "size_in_bytes": 8729
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Hermosillo",
+        "path_type": "hardlink",
+        "sha256": "7391a186f8de1fdd5a61b3887e65dcdb4a2186bfd36bbffb464b63d9775e922a",
+        "sha256_in_prefix": "7391a186f8de1fdd5a61b3887e65dcdb4a2186bfd36bbffb464b63d9775e922a",
+        "size_in_bytes": 616
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Indiana/Indianapolis",
+        "path_type": "hardlink",
+        "sha256": "4b114545167326f066ab3a798180896b43ac6fdc3b80d32bcc917b5a4a2359eb",
+        "sha256_in_prefix": "4b114545167326f066ab3a798180896b43ac6fdc3b80d32bcc917b5a4a2359eb",
+        "size_in_bytes": 7230
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Indiana/Knox",
+        "path_type": "hardlink",
+        "sha256": "f1253f5f3f5aacd1a5e1f4636dd4e083f4b2a8bd995cf3e684cdd384641849f1",
+        "sha256_in_prefix": "f1253f5f3f5aacd1a5e1f4636dd4e083f4b2a8bd995cf3e684cdd384641849f1",
+        "size_in_bytes": 8755
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Indiana/Marengo",
+        "path_type": "hardlink",
+        "sha256": "675162381639598e7100e90663d42780f8ee1cb62bd6da5b948b494f98c02fe3",
+        "sha256_in_prefix": "675162381639598e7100e90663d42780f8ee1cb62bd6da5b948b494f98c02fe3",
+        "size_in_bytes": 7273
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Indiana/Petersburg",
+        "path_type": "hardlink",
+        "sha256": "23b8fa75ce0a9555dfd84549723a12679ff7fc5faa58e4b745ba3c547071ff53",
+        "sha256_in_prefix": "23b8fa75ce0a9555dfd84549723a12679ff7fc5faa58e4b745ba3c547071ff53",
+        "size_in_bytes": 7611
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Indiana/Tell_City",
+        "path_type": "hardlink",
+        "sha256": "d368123db703b55244700876906775837d408c274c5a5801d80b77eadb6d5853",
+        "sha256_in_prefix": "d368123db703b55244700876906775837d408c274c5a5801d80b77eadb6d5853",
+        "size_in_bytes": 7100
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Indiana/Vevay",
+        "path_type": "hardlink",
+        "sha256": "0623233aa39a1a82038a56df255adf49e648777375b8499491c8897ebea1cdf1",
+        "sha256_in_prefix": "0623233aa39a1a82038a56df255adf49e648777375b8499491c8897ebea1cdf1",
+        "size_in_bytes": 6563
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Indiana/Vincennes",
+        "path_type": "hardlink",
+        "sha256": "b8452b6aa739a78ac6d03806463b03d4175639593e19faa3ca4b0d0fb77f18c9",
+        "sha256_in_prefix": "b8452b6aa739a78ac6d03806463b03d4175639593e19faa3ca4b0d0fb77f18c9",
+        "size_in_bytes": 7226
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Indiana/Winamac",
+        "path_type": "hardlink",
+        "sha256": "4b293fdb7680c4597b8c885333719214492ecf09bd5ea342d1ec15f2bf9c8605",
+        "sha256_in_prefix": "4b293fdb7680c4597b8c885333719214492ecf09bd5ea342d1ec15f2bf9c8605",
+        "size_in_bytes": 7410
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Indianapolis",
+        "path_type": "hardlink",
+        "sha256": "437da148b94dba4cea402169878541db9c3419abab6750d1c36625dd3053019e",
+        "sha256_in_prefix": "437da148b94dba4cea402169878541db9c3419abab6750d1c36625dd3053019e",
+        "size_in_bytes": 233
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Inuvik",
+        "path_type": "hardlink",
+        "sha256": "5a1f7f5edad0251b73c33e7b5ddee194646e9d3992b169dc1a64d155765d472c",
+        "sha256_in_prefix": "5a1f7f5edad0251b73c33e7b5ddee194646e9d3992b169dc1a64d155765d472c",
+        "size_in_bytes": 7638
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Iqaluit",
+        "path_type": "hardlink",
+        "sha256": "afc4627879f4a618f5e3ba9ea123f3212e161f4ccfd0df46f3b6b7cd2e2c0d7e",
+        "sha256_in_prefix": "afc4627879f4a618f5e3ba9ea123f3212e161f4ccfd0df46f3b6b7cd2e2c0d7e",
+        "size_in_bytes": 7671
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Jamaica",
+        "path_type": "hardlink",
+        "sha256": "4b9d5177cba057cd53d53120a49b8a47eccb00150018581a84851e9d5437d643",
+        "sha256_in_prefix": "4b9d5177cba057cd53d53120a49b8a47eccb00150018581a84851e9d5437d643",
+        "size_in_bytes": 847
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Jujuy",
+        "path_type": "hardlink",
+        "sha256": "4a0495852cd4d0652b82fb57024645916db8f192eef9a82afd580d87f4d496ed",
+        "sha256_in_prefix": "4a0495852cd4d0652b82fb57024645916db8f192eef9a82afd580d87f4d496ed",
+        "size_in_bytes": 211
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Juneau",
+        "path_type": "hardlink",
+        "sha256": "5fbe6a1fa2d3dfe23c7378e425f32bebca44735da25ea075a7e5ce24bfd4049d",
+        "sha256_in_prefix": "5fbe6a1fa2d3dfe23c7378e425f32bebca44735da25ea075a7e5ce24bfd4049d",
+        "size_in_bytes": 8682
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Kentucky/Louisville",
+        "path_type": "hardlink",
+        "sha256": "9eb1f2b19c44a55d6cc9fd1465baf6535856941c067831e4b5e0494665014bf5",
+        "sha256_in_prefix": "9eb1f2b19c44a55d6cc9fd1465baf6535856941c067831e4b5e0494665014bf5",
+        "size_in_bytes": 9553
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Kentucky/Monticello",
+        "path_type": "hardlink",
+        "sha256": "1c6c7fb0ae628eb6bb305b51859c4e5594a6b0876c386ed9c1c3355e7cb37ae1",
+        "sha256_in_prefix": "1c6c7fb0ae628eb6bb305b51859c4e5594a6b0876c386ed9c1c3355e7cb37ae1",
+        "size_in_bytes": 8558
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Knox_IN",
+        "path_type": "hardlink",
+        "sha256": "d66e77e6ff789d4d6ca13cdb204b977e1fe64be9afee7b41f2c17ed8217fd025",
+        "sha256_in_prefix": "d66e77e6ff789d4d6ca13cdb204b977e1fe64be9afee7b41f2c17ed8217fd025",
+        "size_in_bytes": 204
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Kralendijk",
+        "path_type": "hardlink",
+        "sha256": "5af9b28c48661fdc81762d249b716ba077f0a40ecf431d34a893bb7eaba57965",
+        "sha256_in_prefix": "5af9b28c48661fdc81762d249b716ba077f0a40ecf431d34a893bb7eaba57965",
+        "size_in_bytes": 204
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/La_Paz",
+        "path_type": "hardlink",
+        "sha256": "5488d98aa3c29d710c6af92c42ace36550a5bff78c155cdf8769ee31f71cf033",
+        "sha256_in_prefix": "5488d98aa3c29d710c6af92c42ace36550a5bff78c155cdf8769ee31f71cf033",
+        "size_in_bytes": 218
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Lima",
+        "path_type": "hardlink",
+        "sha256": "6e01002f264df9a6fc247f95399f4f42dccc7ab890b0c259de93dcc97dec89ce",
+        "sha256_in_prefix": "6e01002f264df9a6fc247f95399f4f42dccc7ab890b0c259de93dcc97dec89ce",
+        "size_in_bytes": 460
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Los_Angeles",
+        "path_type": "hardlink",
+        "sha256": "da3f7572f04e6ae78b8f044761e6f48d37ee259a9c1fe15a67072cc64a299fdb",
+        "sha256_in_prefix": "da3f7572f04e6ae78b8f044761e6f48d37ee259a9c1fe15a67072cc64a299fdb",
+        "size_in_bytes": 9726
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Louisville",
+        "path_type": "hardlink",
+        "sha256": "f85c1253f4c1d3e85757d3dea4fd3c61f1aa7be6baae8cb8579278412905acb2",
+        "sha256_in_prefix": "f85c1253f4c1d3e85757d3dea4fd3c61f1aa7be6baae8cb8579278412905acb2",
+        "size_in_bytes": 228
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Lower_Princes",
+        "path_type": "hardlink",
+        "sha256": "1e786229b84ce86db6316b24c85f7cf4cfe66011f973053ad0e108bfcc9a9de2",
+        "sha256_in_prefix": "1e786229b84ce86db6316b24c85f7cf4cfe66011f973053ad0e108bfcc9a9de2",
+        "size_in_bytes": 207
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Maceio",
+        "path_type": "hardlink",
+        "sha256": "f65c5957d434a87324aad35991e7666e426a20c40432540d9a3cb1eee9141761",
+        "sha256_in_prefix": "f65c5957d434a87324aad35991e7666e426a20c40432540d9a3cb1eee9141761",
+        "size_in_bytes": 1539
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Managua",
+        "path_type": "hardlink",
+        "sha256": "f0f0cce8de92d848a62b56ef48e01d763b80153c077230c435d464cf1733ba38",
+        "sha256_in_prefix": "f0f0cce8de92d848a62b56ef48e01d763b80153c077230c435d464cf1733ba38",
+        "size_in_bytes": 611
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Manaus",
+        "path_type": "hardlink",
+        "sha256": "dc54e6d4fe14458b0462fa0e15b960fd4290930adc0d13453bf49b436ed8c143",
+        "sha256_in_prefix": "dc54e6d4fe14458b0462fa0e15b960fd4290930adc0d13453bf49b436ed8c143",
+        "size_in_bytes": 1166
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Marigot",
+        "path_type": "hardlink",
+        "sha256": "5c26d7ce93f91cc4f5ed87e9388b1b180ef9d84681044fd23cc01a628a1284ca",
+        "sha256_in_prefix": "5c26d7ce93f91cc4f5ed87e9388b1b180ef9d84681044fd23cc01a628a1284ca",
+        "size_in_bytes": 201
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Martinique",
+        "path_type": "hardlink",
+        "sha256": "d411fb42798e93b106275ec0e054f8f3c4e9fb49431c656448739c7f20c46ede",
+        "sha256_in_prefix": "d411fb42798e93b106275ec0e054f8f3c4e9fb49431c656448739c7f20c46ede",
+        "size_in_bytes": 251
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Matamoros",
+        "path_type": "hardlink",
+        "sha256": "6738b94878d0cf4d88206858aba03d18b0a2de71d8f051b7d19c2c367dd59d79",
+        "sha256_in_prefix": "6738b94878d0cf4d88206858aba03d18b0a2de71d8f051b7d19c2c367dd59d79",
+        "size_in_bytes": 6745
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Mazatlan",
+        "path_type": "hardlink",
+        "sha256": "f1e4e853758a3d79013d5b24ae45fdfd41a7c110949a5c5db96cf14b479fa741",
+        "sha256_in_prefix": "f1e4e853758a3d79013d5b24ae45fdfd41a7c110949a5c5db96cf14b479fa741",
+        "size_in_bytes": 6841
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Mendoza",
+        "path_type": "hardlink",
+        "sha256": "d6b308a1619f2de450dacbfef0e11b237df7375a80c90899dd02b827688cb4b8",
+        "sha256_in_prefix": "d6b308a1619f2de450dacbfef0e11b237df7375a80c90899dd02b827688cb4b8",
+        "size_in_bytes": 219
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Menominee",
+        "path_type": "hardlink",
+        "sha256": "b0863f8b66f0848020651b69e7997307d62209259ae653fdc1a0fafc8e793068",
+        "sha256_in_prefix": "b0863f8b66f0848020651b69e7997307d62209259ae653fdc1a0fafc8e793068",
+        "size_in_bytes": 8410
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Merida",
+        "path_type": "hardlink",
+        "sha256": "2b4facfc69a195c646842a8b47afe76d755ceedad536dee7ece79302baf97223",
+        "sha256_in_prefix": "2b4facfc69a195c646842a8b47afe76d755ceedad536dee7ece79302baf97223",
+        "size_in_bytes": 6651
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Metlakatla",
+        "path_type": "hardlink",
+        "sha256": "2574831391092ad44d7b2806eef30d59ce3bae872111917dd39ec51efdd62e5f",
+        "sha256_in_prefix": "2574831391092ad44d7b2806eef30d59ce3bae872111917dd39ec51efdd62e5f",
+        "size_in_bytes": 6705
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Mexico_City",
+        "path_type": "hardlink",
+        "sha256": "3458eaf721c1cdf565b5addb487b4f1b93fa46744e9e5fc91d74787173b233a4",
+        "sha256_in_prefix": "3458eaf721c1cdf565b5addb487b4f1b93fa46744e9e5fc91d74787173b233a4",
+        "size_in_bytes": 7035
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Miquelon",
+        "path_type": "hardlink",
+        "sha256": "1b131ac968f95652667bd7eb1f6d667c8f679b31270d82b4b4271e787386ccca",
+        "sha256_in_prefix": "1b131ac968f95652667bd7eb1f6d667c8f679b31270d82b4b4271e787386ccca",
+        "size_in_bytes": 7080
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Moncton",
+        "path_type": "hardlink",
+        "sha256": "d977d045de5cdaeb41189b91963e03ef845ca4b45e496649b4cb541ee1b5dd22",
+        "sha256_in_prefix": "d977d045de5cdaeb41189b91963e03ef845ca4b45e496649b4cb541ee1b5dd22",
+        "size_in_bytes": 10507
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Monterrey",
+        "path_type": "hardlink",
+        "sha256": "63813975bc90a2ae8a6500d7a3173a3c81c060f8b5aaa3e86d5fdc4d5f06abd8",
+        "sha256_in_prefix": "63813975bc90a2ae8a6500d7a3173a3c81c060f8b5aaa3e86d5fdc4d5f06abd8",
+        "size_in_bytes": 6714
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Montevideo",
+        "path_type": "hardlink",
+        "sha256": "214f97a3bcb2378cce23d280ea6a3b691604f82e383628f666be585bb8494932",
+        "sha256_in_prefix": "214f97a3bcb2378cce23d280ea6a3b691604f82e383628f666be585bb8494932",
+        "size_in_bytes": 2936
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Montreal",
+        "path_type": "hardlink",
+        "sha256": "97f48948ef5108fe1f42d548ea47c88d4b51bf1896ee92634c7ed55555b06dbd",
+        "sha256_in_prefix": "97f48948ef5108fe1f42d548ea47c88d4b51bf1896ee92634c7ed55555b06dbd",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Montserrat",
+        "path_type": "hardlink",
+        "sha256": "6c3ee46983a3daa91c9adf4b18d6b4b80f1505b0057569b66d5b465d4c09b9c1",
+        "sha256_in_prefix": "6c3ee46983a3daa91c9adf4b18d6b4b80f1505b0057569b66d5b465d4c09b9c1",
+        "size_in_bytes": 204
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Nassau",
+        "path_type": "hardlink",
+        "sha256": "a889810b8bb42cd206d8f8961164ad03ccfbb1924d583075489f78afa10eaf67",
+        "sha256_in_prefix": "a889810b8bb42cd206d8f8961164ad03ccfbb1924d583075489f78afa10eaf67",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/New_York",
+        "path_type": "hardlink",
+        "sha256": "7ba7da179aa7df26ac25e7accd9bd83784174445285a0d9ccbd7d6a9aa34f4bc",
+        "sha256_in_prefix": "7ba7da179aa7df26ac25e7accd9bd83784174445285a0d9ccbd7d6a9aa34f4bc",
+        "size_in_bytes": 11373
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Nipigon",
+        "path_type": "hardlink",
+        "sha256": "bb4ba3c15c626f6f94ac026a7c3d5dfe3854b17cbfa3f540ffaffd9d5b491083",
+        "sha256_in_prefix": "bb4ba3c15c626f6f94ac026a7c3d5dfe3854b17cbfa3f540ffaffd9d5b491083",
+        "size_in_bytes": 8100
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Nome",
+        "path_type": "hardlink",
+        "sha256": "8e971c9560cce548b46626d072e62ab0f4c9682bf6a6abfb4d0e8d63745402fe",
+        "sha256_in_prefix": "8e971c9560cce548b46626d072e62ab0f4c9682bf6a6abfb4d0e8d63745402fe",
+        "size_in_bytes": 8680
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Noronha",
+        "path_type": "hardlink",
+        "sha256": "9011c76295e6b17cc1973876b497bee21b9e6562fb25df66140f811a1ffa9765",
+        "sha256_in_prefix": "9011c76295e6b17cc1973876b497bee21b9e6562fb25df66140f811a1ffa9765",
+        "size_in_bytes": 1397
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/North_Dakota/Beulah",
+        "path_type": "hardlink",
+        "sha256": "d0d8b108453265b60f525a4ec04de9555087cd6ac5ddba980b3a96cf0fcd68d1",
+        "sha256_in_prefix": "d0d8b108453265b60f525a4ec04de9555087cd6ac5ddba980b3a96cf0fcd68d1",
+        "size_in_bytes": 8557
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/North_Dakota/Center",
+        "path_type": "hardlink",
+        "sha256": "abc2b6c97d9e9fba37ac582adba2ce996890d090060e083405d75cdaed9eabe0",
+        "sha256_in_prefix": "abc2b6c97d9e9fba37ac582adba2ce996890d090060e083405d75cdaed9eabe0",
+        "size_in_bytes": 8557
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/North_Dakota/New_Salem",
+        "path_type": "hardlink",
+        "sha256": "8803ff7c81c933b57178b9d3c502fb4268d9aa594a3c638a7f17af60b12d300d",
+        "sha256_in_prefix": "8803ff7c81c933b57178b9d3c502fb4268d9aa594a3c638a7f17af60b12d300d",
+        "size_in_bytes": 8560
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Nuuk",
+        "path_type": "hardlink",
+        "sha256": "12917daaa60134bfe56e6979bb27b58a3f295c32bae02b233e849bced6b8bca2",
+        "sha256_in_prefix": "12917daaa60134bfe56e6979bb27b58a3f295c32bae02b233e849bced6b8bca2",
+        "size_in_bytes": 7429
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Ojinaga",
+        "path_type": "hardlink",
+        "sha256": "549e92bdec98d21c5c4a996f954671a2f0262463415bf294d122500246309bc4",
+        "sha256_in_prefix": "549e92bdec98d21c5c4a996f954671a2f0262463415bf294d122500246309bc4",
+        "size_in_bytes": 6843
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Panama",
+        "path_type": "hardlink",
+        "sha256": "990213dde00adceb74c8d1ecaf81b9c77963e4ab1f35767f7349236fc8e917df",
+        "sha256_in_prefix": "990213dde00adceb74c8d1ecaf81b9c77963e4ab1f35767f7349236fc8e917df",
+        "size_in_bytes": 186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Pangnirtung",
+        "path_type": "hardlink",
+        "sha256": "1fb962ecc1e5f02e1001c70460fff720b114554f9aa7956d6da154dbea87b4d7",
+        "sha256_in_prefix": "1fb962ecc1e5f02e1001c70460fff720b114554f9aa7956d6da154dbea87b4d7",
+        "size_in_bytes": 7736
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Paramaribo",
+        "path_type": "hardlink",
+        "sha256": "b3ee44b3526bedfc25b806371d3c465fdbd6cc647f30bf093750651e4a0c1be4",
+        "sha256_in_prefix": "b3ee44b3526bedfc25b806371d3c465fdbd6cc647f30bf093750651e4a0c1be4",
+        "size_in_bytes": 253
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Phoenix",
+        "path_type": "hardlink",
+        "sha256": "dfa0ec91804b789a1a7e1b1977710435d2589a5b54c1579c8e1f5bf96d2fd007",
+        "sha256_in_prefix": "dfa0ec91804b789a1a7e1b1977710435d2589a5b54c1579c8e1f5bf96d2fd007",
+        "size_in_bytes": 496
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Port-au-Prince",
+        "path_type": "hardlink",
+        "sha256": "a89c580899ad2ff8df45a783bb90d501dc32c28b92931ca18abd13453e76244b",
+        "sha256_in_prefix": "a89c580899ad2ff8df45a783bb90d501dc32c28b92931ca18abd13453e76244b",
+        "size_in_bytes": 6613
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Port_of_Spain",
+        "path_type": "hardlink",
+        "sha256": "a4952380c89a6903ffe5bf8707b94b1bb72568ffd03db04bf4d98e38ac82eeb7",
+        "sha256_in_prefix": "a4952380c89a6903ffe5bf8707b94b1bb72568ffd03db04bf4d98e38ac82eeb7",
+        "size_in_bytes": 207
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Porto_Acre",
+        "path_type": "hardlink",
+        "sha256": "52921eea2a1925df06cea4638ed4128faaa8fba40ed4e0741650b419e5152dcb",
+        "sha256_in_prefix": "52921eea2a1925df06cea4638ed4128faaa8fba40ed4e0741650b419e5152dcb",
+        "size_in_bytes": 201
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Porto_Velho",
+        "path_type": "hardlink",
+        "sha256": "e6e6f6753e7d443052a64d4db07b8d443ce13a573946e7d0a19cdd4bba4a2f04",
+        "sha256_in_prefix": "e6e6f6753e7d443052a64d4db07b8d443ce13a573946e7d0a19cdd4bba4a2f04",
+        "size_in_bytes": 1051
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Puerto_Rico",
+        "path_type": "hardlink",
+        "sha256": "2981248a9f14ebfc8791ec5453170376cbd549557e495ea0e331cc18556c958e",
+        "sha256_in_prefix": "2981248a9f14ebfc8791ec5453170376cbd549557e495ea0e331cc18556c958e",
+        "size_in_bytes": 283
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Punta_Arenas",
+        "path_type": "hardlink",
+        "sha256": "22418567d55a0e38cab005665271d9279a384856fdf0ce5a9aeabdcd66ccbc72",
+        "sha256_in_prefix": "22418567d55a0e38cab005665271d9279a384856fdf0ce5a9aeabdcd66ccbc72",
+        "size_in_bytes": 3698
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Rainy_River",
+        "path_type": "hardlink",
+        "sha256": "b1630fa919d652f30d23253e1c561bb76fb4d28844a2f614d08b0a25b17cfb27",
+        "sha256_in_prefix": "b1630fa919d652f30d23253e1c561bb76fb4d28844a2f614d08b0a25b17cfb27",
+        "size_in_bytes": 8104
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Rankin_Inlet",
+        "path_type": "hardlink",
+        "sha256": "aa8866d58beab07548180628ff423887bbf48aadb1b55392b288f7310f94a9b1",
+        "sha256_in_prefix": "aa8866d58beab07548180628ff423887bbf48aadb1b55392b288f7310f94a9b1",
+        "size_in_bytes": 7614
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Recife",
+        "path_type": "hardlink",
+        "sha256": "a36ad4614fc9a2a433712b555156ede03980b88eb91d8dc7e8b10451d6d7f7d3",
+        "sha256_in_prefix": "a36ad4614fc9a2a433712b555156ede03980b88eb91d8dc7e8b10451d6d7f7d3",
+        "size_in_bytes": 1420
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Regina",
+        "path_type": "hardlink",
+        "sha256": "50105e788288cf4c680b29bbdcde94d8713a5361b38c6c469fd97cf05503ff7d",
+        "sha256_in_prefix": "50105e788288cf4c680b29bbdcde94d8713a5361b38c6c469fd97cf05503ff7d",
+        "size_in_bytes": 1781
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Resolute",
+        "path_type": "hardlink",
+        "sha256": "643cc43e3f906779c040e1f0c20e78d6e95cc7301b3c7370a8adbcbd76a8c5e8",
+        "sha256_in_prefix": "643cc43e3f906779c040e1f0c20e78d6e95cc7301b3c7370a8adbcbd76a8c5e8",
+        "size_in_bytes": 7610
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Rio_Branco",
+        "path_type": "hardlink",
+        "sha256": "28082d20872b61d6098d31d1c40f12464a946a933cd9af74475c5af384210890",
+        "sha256_in_prefix": "28082d20872b61d6098d31d1c40f12464a946a933cd9af74475c5af384210890",
+        "size_in_bytes": 1112
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Rosario",
+        "path_type": "hardlink",
+        "sha256": "0117d33d4f326aa536162d36a02439fbd5f2eb3b4f540b5ba91ed7747ddac180",
+        "sha256_in_prefix": "0117d33d4f326aa536162d36a02439fbd5f2eb3b4f540b5ba91ed7747ddac180",
+        "size_in_bytes": 219
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Santa_Isabel",
+        "path_type": "hardlink",
+        "sha256": "3b4c2f3a5b9cd22a73f05187c032723d07bb53c9946d04d35e1ba1cb90ca0a62",
+        "sha256_in_prefix": "3b4c2f3a5b9cd22a73f05187c032723d07bb53c9946d04d35e1ba1cb90ca0a62",
+        "size_in_bytes": 194
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Santarem",
+        "path_type": "hardlink",
+        "sha256": "4a397bd937de1d7e6a941d18001b34d4cd195aefd08951c30c7ee8e48656aa0e",
+        "sha256_in_prefix": "4a397bd937de1d7e6a941d18001b34d4cd195aefd08951c30c7ee8e48656aa0e",
+        "size_in_bytes": 1079
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Santiago",
+        "path_type": "hardlink",
+        "sha256": "b2d7fd4db34800c9ef9bd73cddb1105543cced05f3e2ac99f3e5e2f6cf340ae2",
+        "sha256_in_prefix": "b2d7fd4db34800c9ef9bd73cddb1105543cced05f3e2ac99f3e5e2f6cf340ae2",
+        "size_in_bytes": 8871
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Santo_Domingo",
+        "path_type": "hardlink",
+        "sha256": "2217e72b11a90f2d679c175de3cc0f2fed4c280c9ff9707cffaf118bf9a06a4b",
+        "sha256_in_prefix": "2217e72b11a90f2d679c175de3cc0f2fed4c280c9ff9707cffaf118bf9a06a4b",
+        "size_in_bytes": 616
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Sao_Paulo",
+        "path_type": "hardlink",
+        "sha256": "0e7ba1c5a3fa3dabdaa226bfe1e8d797a3835ea554828881ab5e365eda09b92e",
+        "sha256_in_prefix": "0e7ba1c5a3fa3dabdaa226bfe1e8d797a3835ea554828881ab5e365eda09b92e",
+        "size_in_bytes": 2900
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Scoresbysund",
+        "path_type": "hardlink",
+        "sha256": "158bd9e4eb0b9dff3f2d3e2dba72f217b73423012dd33a688fd57852124e884a",
+        "sha256_in_prefix": "158bd9e4eb0b9dff3f2d3e2dba72f217b73423012dd33a688fd57852124e884a",
+        "size_in_bytes": 6839
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Shiprock",
+        "path_type": "hardlink",
+        "sha256": "bf4fab3ae72cc7fa4f9e34cf0551a85c54a084cd826df5d9cc684de6188e84db",
+        "sha256_in_prefix": "bf4fab3ae72cc7fa4f9e34cf0551a85c54a084cd826df5d9cc684de6188e84db",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Sitka",
+        "path_type": "hardlink",
+        "sha256": "abb08435cae80119068a85984bffe9c1596f4fb90f07cc01124c907e5162c189",
+        "sha256_in_prefix": "abb08435cae80119068a85984bffe9c1596f4fb90f07cc01124c907e5162c189",
+        "size_in_bytes": 8651
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/St_Barthelemy",
+        "path_type": "hardlink",
+        "sha256": "353cdbd46ba8c7472a93e9e800a69105801f6784b22ec50a59294cdc3be40e18",
+        "sha256_in_prefix": "353cdbd46ba8c7472a93e9e800a69105801f6784b22ec50a59294cdc3be40e18",
+        "size_in_bytes": 207
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/St_Johns",
+        "path_type": "hardlink",
+        "sha256": "e2917204b0c843c32051bb371cf6d0ad272c02720b9c0d913ac072c8abe1ec64",
+        "sha256_in_prefix": "e2917204b0c843c32051bb371cf6d0ad272c02720b9c0d913ac072c8abe1ec64",
+        "size_in_bytes": 11289
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/St_Kitts",
+        "path_type": "hardlink",
+        "sha256": "edb9457a7c64e47062bdc6458fd3bcfcd6c37820f1a2bc89dfe99ed77355011f",
+        "sha256_in_prefix": "edb9457a7c64e47062bdc6458fd3bcfcd6c37820f1a2bc89dfe99ed77355011f",
+        "size_in_bytes": 202
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/St_Lucia",
+        "path_type": "hardlink",
+        "sha256": "6727a509bb937cb3446d41b57826de70c7028e96f088ab5b7f803beaa18279e8",
+        "sha256_in_prefix": "6727a509bb937cb3446d41b57826de70c7028e96f088ab5b7f803beaa18279e8",
+        "size_in_bytes": 202
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/St_Thomas",
+        "path_type": "hardlink",
+        "sha256": "974aeed3d79124b50265c83d84f23cbe4f0328d00c75f42dd3abc5d4c0a78de1",
+        "sha256_in_prefix": "974aeed3d79124b50265c83d84f23cbe4f0328d00c75f42dd3abc5d4c0a78de1",
+        "size_in_bytes": 203
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/St_Vincent",
+        "path_type": "hardlink",
+        "sha256": "6b19404d295964ef66f47802836bb728fce8e6481115797c0b5f200c354d7c8a",
+        "sha256_in_prefix": "6b19404d295964ef66f47802836bb728fce8e6481115797c0b5f200c354d7c8a",
+        "size_in_bytes": 204
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Swift_Current",
+        "path_type": "hardlink",
+        "sha256": "939b25c9412b9e25d73f552e87826999fc8c929770e66491d1e4530046d3e758",
+        "sha256_in_prefix": "939b25c9412b9e25d73f552e87826999fc8c929770e66491d1e4530046d3e758",
+        "size_in_bytes": 874
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Tegucigalpa",
+        "path_type": "hardlink",
+        "sha256": "1f0503579b0dddbaf88814a278127d9cd7019edd3c35f4cbfc0ef11c0edafe5b",
+        "sha256_in_prefix": "1f0503579b0dddbaf88814a278127d9cd7019edd3c35f4cbfc0ef11c0edafe5b",
+        "size_in_bytes": 341
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Thule",
+        "path_type": "hardlink",
+        "sha256": "7fb0cbb101d3b6fbb6b9dad5446bbf9e6aec65ec38472739e604f68f6aa9ab7b",
+        "sha256_in_prefix": "7fb0cbb101d3b6fbb6b9dad5446bbf9e6aec65ec38472739e604f68f6aa9ab7b",
+        "size_in_bytes": 6890
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Thunder_Bay",
+        "path_type": "hardlink",
+        "sha256": "0f95ce0a36415b43e7b5e6cd790d3bd9ef6d53f4b7aa0235360c0847cbb3f0c1",
+        "sha256_in_prefix": "0f95ce0a36415b43e7b5e6cd790d3bd9ef6d53f4b7aa0235360c0847cbb3f0c1",
+        "size_in_bytes": 8330
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Tijuana",
+        "path_type": "hardlink",
+        "sha256": "fe3681f580ed7f3f2fd21f510dff1bef81bd521737f5846fa15fd309e44e69be",
+        "sha256_in_prefix": "fe3681f580ed7f3f2fd21f510dff1bef81bd521737f5846fa15fd309e44e69be",
+        "size_in_bytes": 8755
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Toronto",
+        "path_type": "hardlink",
+        "sha256": "5a98c6bedda4df608051d702a8e037093a8068e1b85f8f55d42b4468f45662a5",
+        "sha256_in_prefix": "5a98c6bedda4df608051d702a8e037093a8068e1b85f8f55d42b4468f45662a5",
+        "size_in_bytes": 11248
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Tortola",
+        "path_type": "hardlink",
+        "sha256": "46a236ec38f3a122d414208328a462b2a937392ecc6c55f673fb7a402f118d96",
+        "sha256_in_prefix": "46a236ec38f3a122d414208328a462b2a937392ecc6c55f673fb7a402f118d96",
+        "size_in_bytes": 201
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Vancouver",
+        "path_type": "hardlink",
+        "sha256": "00b5fb8f37dff43925c501aeab039f39f058e002572c4203286317046cc1d700",
+        "sha256_in_prefix": "00b5fb8f37dff43925c501aeab039f39f058e002572c4203286317046cc1d700",
+        "size_in_bytes": 9815
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Virgin",
+        "path_type": "hardlink",
+        "sha256": "561d9d04b0ce0f96a9c351c7d5c30aa1d5a42a3d70066cd9af0da6cbc5388dbe",
+        "sha256_in_prefix": "561d9d04b0ce0f96a9c351c7d5c30aa1d5a42a3d70066cd9af0da6cbc5388dbe",
+        "size_in_bytes": 200
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Whitehorse",
+        "path_type": "hardlink",
+        "sha256": "8e0bc71bd7146145dde3c064ae205df08124fe2402853a9655b0eb799e90f31f",
+        "sha256_in_prefix": "8e0bc71bd7146145dde3c064ae205df08124fe2402853a9655b0eb799e90f31f",
+        "size_in_bytes": 2971
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Winnipeg",
+        "path_type": "hardlink",
+        "sha256": "f3fc5f6d93d1d9eb0f3ded33873f33c47f841797d96439966f8e0a5a189941fa",
+        "sha256_in_prefix": "f3fc5f6d93d1d9eb0f3ded33873f33c47f841797d96439966f8e0a5a189941fa",
+        "size_in_bytes": 9695
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Yakutat",
+        "path_type": "hardlink",
+        "sha256": "79b44f245d86a4ec299d1a9a2edb2ab92d50ab5a7c1c03759d283ac4070f9005",
+        "sha256_in_prefix": "79b44f245d86a4ec299d1a9a2edb2ab92d50ab5a7c1c03759d283ac4070f9005",
+        "size_in_bytes": 8683
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/America/Yellowknife",
+        "path_type": "hardlink",
+        "sha256": "b33838f12640c64ba4f10f50657ec4d8d5b30fd226da4aca21b169b53ad30576",
+        "sha256_in_prefix": "b33838f12640c64ba4f10f50657ec4d8d5b30fd226da4aca21b169b53ad30576",
+        "size_in_bytes": 7737
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/Casey",
+        "path_type": "hardlink",
+        "sha256": "04247acb2b4fa126d13f4573ff74d15a89cf42b2c5cd7e688d5bb1c1fd3972bf",
+        "sha256_in_prefix": "04247acb2b4fa126d13f4573ff74d15a89cf42b2c5cd7e688d5bb1c1fd3972bf",
+        "size_in_bytes": 478
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/Davis",
+        "path_type": "hardlink",
+        "sha256": "2f36d2e13d7e251322b7a7b30f39645393525ceb49a2b5c26f27797f2aaf4d7f",
+        "sha256_in_prefix": "2f36d2e13d7e251322b7a7b30f39645393525ceb49a2b5c26f27797f2aaf4d7f",
+        "size_in_bytes": 324
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/DumontDUrville",
+        "path_type": "hardlink",
+        "sha256": "96f2ab9a9ffcd10598fdf105f68460cc4b4ebc1f18054d1bc8e39df6ad24d1ac",
+        "sha256_in_prefix": "96f2ab9a9ffcd10598fdf105f68460cc4b4ebc1f18054d1bc8e39df6ad24d1ac",
+        "size_in_bytes": 214
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/Macquarie",
+        "path_type": "hardlink",
+        "sha256": "c4ea7f1c0b5a0fae653419f1c6d058bddd745a3cdba11900005c157df23ddc01",
+        "sha256_in_prefix": "c4ea7f1c0b5a0fae653419f1c6d058bddd745a3cdba11900005c157df23ddc01",
+        "size_in_bytes": 8447
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/Mawson",
+        "path_type": "hardlink",
+        "sha256": "aca533b8bc82296373edec82f6e0aa45a34d817c7c18ff5e8e94b81c0bd30259",
+        "sha256_in_prefix": "aca533b8bc82296373edec82f6e0aa45a34d817c7c18ff5e8e94b81c0bd30259",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/McMurdo",
+        "path_type": "hardlink",
+        "sha256": "e9d99293c5b275d8e0d7b066084177edf670d5b52b81e87608bab02025f33155",
+        "sha256_in_prefix": "e9d99293c5b275d8e0d7b066084177edf670d5b52b81e87608bab02025f33155",
+        "size_in_bytes": 195
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/Palmer",
+        "path_type": "hardlink",
+        "sha256": "1637381a20e9d5c6a530f110bdb08d9515e675c9206f000407d8511074948e61",
+        "sha256_in_prefix": "1637381a20e9d5c6a530f110bdb08d9515e675c9206f000407d8511074948e61",
+        "size_in_bytes": 2613
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/Rothera",
+        "path_type": "hardlink",
+        "sha256": "943f10d8e836773f0b7acd13ed8422c0b27813c7bbe0b09b57697d1d70d21ece",
+        "sha256_in_prefix": "943f10d8e836773f0b7acd13ed8422c0b27813c7bbe0b09b57697d1d70d21ece",
+        "size_in_bytes": 151
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/South_Pole",
+        "path_type": "hardlink",
+        "sha256": "88057832175bb642b23fc99f788a2f78a24005cf1f84a7b1b5e8c84fb8f4d4c1",
+        "sha256_in_prefix": "88057832175bb642b23fc99f788a2f78a24005cf1f84a7b1b5e8c84fb8f4d4c1",
+        "size_in_bytes": 198
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/Syowa",
+        "path_type": "hardlink",
+        "sha256": "2488805de4fea42305689f679f1ae2d80b1e934e657fea329ad39a82dac63022",
+        "sha256_in_prefix": "2488805de4fea42305689f679f1ae2d80b1e934e657fea329ad39a82dac63022",
+        "size_in_bytes": 178
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/Troll",
+        "path_type": "hardlink",
+        "sha256": "6fd5ab8b7b308cdcea4b747a81d8675988ae218813c91714fc4ca97919cebea5",
+        "sha256_in_prefix": "6fd5ab8b7b308cdcea4b747a81d8675988ae218813c91714fc4ca97919cebea5",
+        "size_in_bytes": 5370
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Antarctica/Vostok",
+        "path_type": "hardlink",
+        "sha256": "1efdae8a23ba4ee37e7992f3c9dcada6c2e95af82a955a4c6597e7295c950855",
+        "sha256_in_prefix": "1efdae8a23ba4ee37e7992f3c9dcada6c2e95af82a955a4c6597e7295c950855",
+        "size_in_bytes": 150
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Arctic/Longyearbyen",
+        "path_type": "hardlink",
+        "sha256": "944a38702a5176a082755897f1e4b1c88d5721cb499245e2fe51d2cfd849a23f",
+        "sha256_in_prefix": "944a38702a5176a082755897f1e4b1c88d5721cb499245e2fe51d2cfd849a23f",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Aden",
+        "path_type": "hardlink",
+        "sha256": "8fcddb246932baed880b70c0ca867057e7989aea55eddc174430e1055cd1058d",
+        "sha256_in_prefix": "8fcddb246932baed880b70c0ca867057e7989aea55eddc174430e1055cd1058d",
+        "size_in_bytes": 171
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Almaty",
+        "path_type": "hardlink",
+        "sha256": "06dc608c0b8cdd69cce66a6bf86f141c46df39cb45312e684e46f19ed8caff15",
+        "sha256_in_prefix": "06dc608c0b8cdd69cce66a6bf86f141c46df39cb45312e684e46f19ed8caff15",
+        "size_in_bytes": 1637
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Amman",
+        "path_type": "hardlink",
+        "sha256": "aa5e87c065e5aa4516f1aa50e1840ee22683d3b4c25a4e00ca92c53f96c6d062",
+        "sha256_in_prefix": "aa5e87c065e5aa4516f1aa50e1840ee22683d3b4c25a4e00ca92c53f96c6d062",
+        "size_in_bytes": 7301
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Anadyr",
+        "path_type": "hardlink",
+        "sha256": "d9df64fda4638f7604624b0f68a885d5abadb1de12af1af5581c2af7dd971562",
+        "sha256_in_prefix": "d9df64fda4638f7604624b0f68a885d5abadb1de12af1af5581c2af7dd971562",
+        "size_in_bytes": 2086
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Aqtau",
+        "path_type": "hardlink",
+        "sha256": "96b510af9b8c6bc1dfa84e9ed5e072f3fd484eeb66bbebc7b6826ed859ed9027",
+        "sha256_in_prefix": "96b510af9b8c6bc1dfa84e9ed5e072f3fd484eeb66bbebc7b6826ed859ed9027",
+        "size_in_bytes": 1665
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Aqtobe",
+        "path_type": "hardlink",
+        "sha256": "991638fa2ab2a2f7a091a23d78d99306ee73a740f1a03fbac448edcab55a0e38",
+        "sha256_in_prefix": "991638fa2ab2a2f7a091a23d78d99306ee73a740f1a03fbac448edcab55a0e38",
+        "size_in_bytes": 1666
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Ashgabat",
+        "path_type": "hardlink",
+        "sha256": "13745bfa25e6e2d8d0fabae42cb7c37cf9f974cfb343d4fe84e4e2d64a25926b",
+        "sha256_in_prefix": "13745bfa25e6e2d8d0fabae42cb7c37cf9f974cfb343d4fe84e4e2d64a25926b",
+        "size_in_bytes": 878
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Ashkhabad",
+        "path_type": "hardlink",
+        "sha256": "2c752f641b98e3c05b14ae31330d1f198daa4a7e354ba9670c7754926bfb891a",
+        "sha256_in_prefix": "2c752f641b98e3c05b14ae31330d1f198daa4a7e354ba9670c7754926bfb891a",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Atyrau",
+        "path_type": "hardlink",
+        "sha256": "4b7b118e6ae72d41740cf0cb2bd8e970700758dcbc0dd6f298199d841df8408e",
+        "sha256_in_prefix": "4b7b118e6ae72d41740cf0cb2bd8e970700758dcbc0dd6f298199d841df8408e",
+        "size_in_bytes": 1666
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Baghdad",
+        "path_type": "hardlink",
+        "sha256": "d20b75d2604c3b742c1629c5ee02cff6783e472249982b272b68f2a6de9bdc38",
+        "sha256_in_prefix": "d20b75d2604c3b742c1629c5ee02cff6783e472249982b272b68f2a6de9bdc38",
+        "size_in_bytes": 1702
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Bahrain",
+        "path_type": "hardlink",
+        "sha256": "3d437037fbf2bbdf969c8e71967080947f24860d431b39f5d8f23151316abcd5",
+        "sha256_in_prefix": "3d437037fbf2bbdf969c8e71967080947f24860d431b39f5d8f23151316abcd5",
+        "size_in_bytes": 171
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Baku",
+        "path_type": "hardlink",
+        "sha256": "873e8f08b87610d0dafe239d32345248a4595c6b13d1da83ec214d78e88fa12c",
+        "sha256_in_prefix": "873e8f08b87610d0dafe239d32345248a4595c6b13d1da83ec214d78e88fa12c",
+        "size_in_bytes": 2149
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Bangkok",
+        "path_type": "hardlink",
+        "sha256": "6e72ba908f250fd45d554a12e3e7b3bd2f1c02a6c2431f806fd2a054f843aa90",
+        "sha256_in_prefix": "6e72ba908f250fd45d554a12e3e7b3bd2f1c02a6c2431f806fd2a054f843aa90",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Barnaul",
+        "path_type": "hardlink",
+        "sha256": "992f93a7975f8cd4e94d96b3ba1ecfb3585e52a53f4442a15993402d3f955f66",
+        "sha256_in_prefix": "992f93a7975f8cd4e94d96b3ba1ecfb3585e52a53f4442a15993402d3f955f66",
+        "size_in_bytes": 2117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Beirut",
+        "path_type": "hardlink",
+        "sha256": "17af14646d562afe17dccfd1d2fba95c122f3e0263906a36eb48bff04acf233e",
+        "sha256_in_prefix": "17af14646d562afe17dccfd1d2fba95c122f3e0263906a36eb48bff04acf233e",
+        "size_in_bytes": 8024
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Bishkek",
+        "path_type": "hardlink",
+        "sha256": "1d5e9a8f6a04273af741f648ef10718b004a60d7884fe432ddf85a8f558bea98",
+        "sha256_in_prefix": "1d5e9a8f6a04273af741f648ef10718b004a60d7884fe432ddf85a8f558bea98",
+        "size_in_bytes": 1669
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Brunei",
+        "path_type": "hardlink",
+        "sha256": "a4216b59f2478de7e88a99e2b11bbbd93070477d7e62bfd453d1ca430ebb4834",
+        "sha256_in_prefix": "a4216b59f2478de7e88a99e2b11bbbd93070477d7e62bfd453d1ca430ebb4834",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Calcutta",
+        "path_type": "hardlink",
+        "sha256": "1baef7850111d2c33b2a766a8ae804534aba1711bf80a4087a89656ddd8469d5",
+        "sha256_in_prefix": "1baef7850111d2c33b2a766a8ae804534aba1711bf80a4087a89656ddd8469d5",
+        "size_in_bytes": 178
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Chita",
+        "path_type": "hardlink",
+        "sha256": "10b6f435b05d887176a4d90ca5ac957f327f62f36f15d6f6e4f81844662429b9",
+        "sha256_in_prefix": "10b6f435b05d887176a4d90ca5ac957f327f62f36f15d6f6e4f81844662429b9",
+        "size_in_bytes": 2086
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Choibalsan",
+        "path_type": "hardlink",
+        "sha256": "94b2c14ef45c695ef6b19d94722e1bcbb629a595f2866dba80f00a66721040b5",
+        "sha256_in_prefix": "94b2c14ef45c695ef6b19d94722e1bcbb629a595f2866dba80f00a66721040b5",
+        "size_in_bytes": 1619
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Chongqing",
+        "path_type": "hardlink",
+        "sha256": "a87382dc5f3c3141547a65e3746af1daf94b51468b96da6cef30e95754c97d37",
+        "sha256_in_prefix": "a87382dc5f3c3141547a65e3746af1daf94b51468b96da6cef30e95754c97d37",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Chungking",
+        "path_type": "hardlink",
+        "sha256": "d6d2b4a761c547f1f853ae901ac71ab49fbe825037079c4e0c89dc940ae4a822",
+        "sha256_in_prefix": "d6d2b4a761c547f1f853ae901ac71ab49fbe825037079c4e0c89dc940ae4a822",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Colombo",
+        "path_type": "hardlink",
+        "sha256": "e5b5e6d607a15da65cb00c92c35a63eaf25f547e64cb34bb419cb8cfc2714b1b",
+        "sha256_in_prefix": "e5b5e6d607a15da65cb00c92c35a63eaf25f547e64cb34bb419cb8cfc2714b1b",
+        "size_in_bytes": 369
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Dacca",
+        "path_type": "hardlink",
+        "sha256": "b3ad560f66ea330e54a147017e6e6ab64452a5255d097b962d540836d7b19ee7",
+        "sha256_in_prefix": "b3ad560f66ea330e54a147017e6e6ab64452a5255d097b962d540836d7b19ee7",
+        "size_in_bytes": 169
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Damascus",
+        "path_type": "hardlink",
+        "sha256": "7d44f4c16e862752d399999b9f0b1e4e8ed5d80c1322a980094801dd8a4a03eb",
+        "sha256_in_prefix": "7d44f4c16e862752d399999b9f0b1e4e8ed5d80c1322a980094801dd8a4a03eb",
+        "size_in_bytes": 8311
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Dhaka",
+        "path_type": "hardlink",
+        "sha256": "bfc4562055cc4355e79f9efaa580a4c6a658285916159a5d390a0cda96a97e98",
+        "sha256_in_prefix": "bfc4562055cc4355e79f9efaa580a4c6a658285916159a5d390a0cda96a97e98",
+        "size_in_bytes": 364
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Dili",
+        "path_type": "hardlink",
+        "sha256": "8bc2e0d77ac35b6d63e11b820ac45ec23a4195ed773680c600c772fdf4b953f8",
+        "sha256_in_prefix": "8bc2e0d77ac35b6d63e11b820ac45ec23a4195ed773680c600c772fdf4b953f8",
+        "size_in_bytes": 235
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Dubai",
+        "path_type": "hardlink",
+        "sha256": "3db174f1568bc23bf467a3dc7baf8a2a2952b70653d4de54f4db391ec50b6925",
+        "sha256_in_prefix": "3db174f1568bc23bf467a3dc7baf8a2a2952b70653d4de54f4db391ec50b6925",
+        "size_in_bytes": 148
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Dushanbe",
+        "path_type": "hardlink",
+        "sha256": "550db44595f59d0f151be4af70d6fece20580ab687ef45de2a0a75fb2515ac80",
+        "sha256_in_prefix": "550db44595f59d0f151be4af70d6fece20580ab687ef45de2a0a75fb2515ac80",
+        "size_in_bytes": 820
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Famagusta",
+        "path_type": "hardlink",
+        "sha256": "8cfe85c48fc22033411432f8b75ee4c097a5d84897698cb1afd5ab51c47ff5a3",
+        "sha256_in_prefix": "8cfe85c48fc22033411432f8b75ee4c097a5d84897698cb1afd5ab51c47ff5a3",
+        "size_in_bytes": 7597
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Gaza",
+        "path_type": "hardlink",
+        "sha256": "f030e2b3dbca556c36602fbf234c7db7d4f222d02cfab192288e91e6a1bf3c90",
+        "sha256_in_prefix": "f030e2b3dbca556c36602fbf234c7db7d4f222d02cfab192288e91e6a1bf3c90",
+        "size_in_bytes": 8427
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Harbin",
+        "path_type": "hardlink",
+        "sha256": "12811a7944b892e3d1c0b4b09057cc1899f28081b3cd47ffd248ba49ba308af0",
+        "sha256_in_prefix": "12811a7944b892e3d1c0b4b09057cc1899f28081b3cd47ffd248ba49ba308af0",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Hebron",
+        "path_type": "hardlink",
+        "sha256": "2c126ba5f78cf7a13fbdfe00f647bb29e2ac104b89ab51b39281047d9b2e45a7",
+        "sha256_in_prefix": "2c126ba5f78cf7a13fbdfe00f647bb29e2ac104b89ab51b39281047d9b2e45a7",
+        "size_in_bytes": 8402
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Ho_Chi_Minh",
+        "path_type": "hardlink",
+        "sha256": "fe977368691f4fa43d068cd8d989f39d2aec46d199d7d629b8dd3ecf7423a335",
+        "sha256_in_prefix": "fe977368691f4fa43d068cd8d989f39d2aec46d199d7d629b8dd3ecf7423a335",
+        "size_in_bytes": 395
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Hong_Kong",
+        "path_type": "hardlink",
+        "sha256": "ee9a6997bc1aad4a8fa95db312774c3f37fbb895549230c30fc66c02cc170eb6",
+        "sha256_in_prefix": "ee9a6997bc1aad4a8fa95db312774c3f37fbb895549230c30fc66c02cc170eb6",
+        "size_in_bytes": 2226
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Hovd",
+        "path_type": "hardlink",
+        "sha256": "ca88a45e954a9854c680b399e69e4858bf5e861fabfadc19d62d97b734b25415",
+        "sha256_in_prefix": "ca88a45e954a9854c680b399e69e4858bf5e861fabfadc19d62d97b734b25415",
+        "size_in_bytes": 1583
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Irkutsk",
+        "path_type": "hardlink",
+        "sha256": "61baaad6315ffbdaed6f266880165b06eccaf72f660b7fb01c8b654f3952d68e",
+        "sha256_in_prefix": "61baaad6315ffbdaed6f266880165b06eccaf72f660b7fb01c8b654f3952d68e",
+        "size_in_bytes": 2089
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Istanbul",
+        "path_type": "hardlink",
+        "sha256": "1f77c4bd27574e1d2066885def01806a02d3e444424a219a8ec5c114f89665e5",
+        "sha256_in_prefix": "1f77c4bd27574e1d2066885def01806a02d3e444424a219a8ec5c114f89665e5",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Jakarta",
+        "path_type": "hardlink",
+        "sha256": "2f39d9f93761b85c254f458317a7de2b4184be9459f2193a85c08662e801269a",
+        "sha256_in_prefix": "2f39d9f93761b85c254f458317a7de2b4184be9459f2193a85c08662e801269a",
+        "size_in_bytes": 370
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Jayapura",
+        "path_type": "hardlink",
+        "sha256": "761c1e80febf46d6d6215cebf211f121974156d9bce2fb4258c1074c6ed2ce22",
+        "sha256_in_prefix": "761c1e80febf46d6d6215cebf211f121974156d9bce2fb4258c1074c6ed2ce22",
+        "size_in_bytes": 213
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Jerusalem",
+        "path_type": "hardlink",
+        "sha256": "0bdc2c693134199c2ecd374cc01468813db29df47422c706a3ea2be5ecca177a",
+        "sha256_in_prefix": "0bdc2c693134199c2ecd374cc01468813db29df47422c706a3ea2be5ecca177a",
+        "size_in_bytes": 8135
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Kabul",
+        "path_type": "hardlink",
+        "sha256": "a59c95c038f2e945d685d96fa9b859ce82a643a1b7f56eb36b2c809de91cd4ba",
+        "sha256_in_prefix": "a59c95c038f2e945d685d96fa9b859ce82a643a1b7f56eb36b2c809de91cd4ba",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Kamchatka",
+        "path_type": "hardlink",
+        "sha256": "6e0278e389072437bc07a5032cd58e9e5b1b2bdb20918632c422efa97bc43abf",
+        "sha256_in_prefix": "6e0278e389072437bc07a5032cd58e9e5b1b2bdb20918632c422efa97bc43abf",
+        "size_in_bytes": 2060
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Karachi",
+        "path_type": "hardlink",
+        "sha256": "4e7f7acae8b4018a835328744f680c8054771805bb0bb07678a09737963c090d",
+        "sha256_in_prefix": "4e7f7acae8b4018a835328744f680c8054771805bb0bb07678a09737963c090d",
+        "size_in_bytes": 457
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Kashgar",
+        "path_type": "hardlink",
+        "sha256": "7b2251f0a41cbadf45d69f24604834167b14d8d33b510e635719ab404cabbce2",
+        "sha256_in_prefix": "7b2251f0a41cbadf45d69f24604834167b14d8d33b510e635719ab404cabbce2",
+        "size_in_bytes": 174
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Kathmandu",
+        "path_type": "hardlink",
+        "sha256": "f0a0816e62036637f75081cbf17a1e6b8fbc2d86aec3cd2e234bbbdd6ec9f109",
+        "sha256_in_prefix": "f0a0816e62036637f75081cbf17a1e6b8fbc2d86aec3cd2e234bbbdd6ec9f109",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Katmandu",
+        "path_type": "hardlink",
+        "sha256": "9acc9586b6f8b53bfe8b242283a434a9a9633d60559ebfdee263b4c8915d50ca",
+        "sha256_in_prefix": "9acc9586b6f8b53bfe8b242283a434a9a9633d60559ebfdee263b4c8915d50ca",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Khandyga",
+        "path_type": "hardlink",
+        "sha256": "33203d7fb7f3d1f848640ece0642a2305e1863b4d47413075e2e7e40bd7418e7",
+        "sha256_in_prefix": "33203d7fb7f3d1f848640ece0642a2305e1863b4d47413075e2e7e40bd7418e7",
+        "size_in_bytes": 2119
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Kolkata",
+        "path_type": "hardlink",
+        "sha256": "6d464564ed2efc9dada1586d4fc99fe333726d2be15a00e30c2391f588896463",
+        "sha256_in_prefix": "6d464564ed2efc9dada1586d4fc99fe333726d2be15a00e30c2391f588896463",
+        "size_in_bytes": 336
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Krasnoyarsk",
+        "path_type": "hardlink",
+        "sha256": "53b8d5e7fb1bd67fece66a933d9bdbb773f14a8c04d316a2a1b00ec6dbc151dd",
+        "sha256_in_prefix": "53b8d5e7fb1bd67fece66a933d9bdbb773f14a8c04d316a2a1b00ec6dbc151dd",
+        "size_in_bytes": 2062
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Kuala_Lumpur",
+        "path_type": "hardlink",
+        "sha256": "25a8328b309b68da85c7a800086a1e4d3c62b96ad97fef24fc429a14c50e762b",
+        "sha256_in_prefix": "25a8328b309b68da85c7a800086a1e4d3c62b96ad97fef24fc429a14c50e762b",
+        "size_in_bytes": 375
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Kuching",
+        "path_type": "hardlink",
+        "sha256": "6e35e560675b0b5322474900d4ec8326c504788c1f82e533b09785deeff092df",
+        "sha256_in_prefix": "6e35e560675b0b5322474900d4ec8326c504788c1f82e533b09785deeff092df",
+        "size_in_bytes": 669
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Kuwait",
+        "path_type": "hardlink",
+        "sha256": "8e0c60a9aa64fb8602edc35311f7436b04853970a21c1f6c871494a09aad5787",
+        "sha256_in_prefix": "8e0c60a9aa64fb8602edc35311f7436b04853970a21c1f6c871494a09aad5787",
+        "size_in_bytes": 173
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Macao",
+        "path_type": "hardlink",
+        "sha256": "4308d741c83b263c7c9fb8ec692a7b7b502135e407b265b12ea7ef92523455c0",
+        "sha256_in_prefix": "4308d741c83b263c7c9fb8ec692a7b7b502135e407b265b12ea7ef92523455c0",
+        "size_in_bytes": 169
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Macau",
+        "path_type": "hardlink",
+        "sha256": "fbcb92cecb1cb0bc284adc30d70c5f57b3afc992136a0d898abc64490bb700fb",
+        "sha256_in_prefix": "fbcb92cecb1cb0bc284adc30d70c5f57b3afc992136a0d898abc64490bb700fb",
+        "size_in_bytes": 2217
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Magadan",
+        "path_type": "hardlink",
+        "sha256": "0c6eeeb7975a95c2b0678d137e6a735238d244a37fa11078050051511de499fe",
+        "sha256_in_prefix": "0c6eeeb7975a95c2b0678d137e6a735238d244a37fa11078050051511de499fe",
+        "size_in_bytes": 2088
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Makassar",
+        "path_type": "hardlink",
+        "sha256": "30d8ab00e32ece51442c0310e650d89d6989e0809600ee334cb10c506d84bf9d",
+        "sha256_in_prefix": "30d8ab00e32ece51442c0310e650d89d6989e0809600ee334cb10c506d84bf9d",
+        "size_in_bytes": 243
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Manila",
+        "path_type": "hardlink",
+        "sha256": "070d61a0e39643a700aba89a8a4be5733ba456958966098405e11ecdfa854d76",
+        "sha256_in_prefix": "070d61a0e39643a700aba89a8a4be5733ba456958966098405e11ecdfa854d76",
+        "size_in_bytes": 421
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Muscat",
+        "path_type": "hardlink",
+        "sha256": "011b7de1c9f7ec241b224bc864d8ae66acb433fbc8ad939e4dbeb12be6390243",
+        "sha256_in_prefix": "011b7de1c9f7ec241b224bc864d8ae66acb433fbc8ad939e4dbeb12be6390243",
+        "size_in_bytes": 170
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Nicosia",
+        "path_type": "hardlink",
+        "sha256": "3c3e4844c70d361893ef022d6c3c8e38b243e91d40c5a726c924355476816f25",
+        "sha256_in_prefix": "3c3e4844c70d361893ef022d6c3c8e38b243e91d40c5a726c924355476816f25",
+        "size_in_bytes": 7625
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Novokuznetsk",
+        "path_type": "hardlink",
+        "sha256": "96a445d47d834c28480d1e2036eca4962b35afa494c219065d4879f71c1830db",
+        "sha256_in_prefix": "96a445d47d834c28480d1e2036eca4962b35afa494c219065d4879f71c1830db",
+        "size_in_bytes": 2063
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Novosibirsk",
+        "path_type": "hardlink",
+        "sha256": "ef799077291f6b3b19e0aec88f224bb592faad09d30740f2376d3d20f2169639",
+        "sha256_in_prefix": "ef799077291f6b3b19e0aec88f224bb592faad09d30740f2376d3d20f2169639",
+        "size_in_bytes": 2121
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Omsk",
+        "path_type": "hardlink",
+        "sha256": "2605cd1e26e4ab48bcb4399bb5b17bad115a47f87ba3dd54b55bb50c3fe82606",
+        "sha256_in_prefix": "2605cd1e26e4ab48bcb4399bb5b17bad115a47f87ba3dd54b55bb50c3fe82606",
+        "size_in_bytes": 2055
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Oral",
+        "path_type": "hardlink",
+        "sha256": "933bbcd7ae0bf59a5b4a6e0ef74c237feedc42e6a3aeb2158131aa70fba6fe47",
+        "sha256_in_prefix": "933bbcd7ae0bf59a5b4a6e0ef74c237feedc42e6a3aeb2158131aa70fba6fe47",
+        "size_in_bytes": 1664
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Phnom_Penh",
+        "path_type": "hardlink",
+        "sha256": "dcee88876d00396918f43deca421b6c9b02f84b5866a2ce16e641b814b390a9f",
+        "sha256_in_prefix": "dcee88876d00396918f43deca421b6c9b02f84b5866a2ce16e641b814b390a9f",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Pontianak",
+        "path_type": "hardlink",
+        "sha256": "ac8370aedf5fe3fe1e80710ce117dee23815be377d418e4b4f3259a1930e8dbf",
+        "sha256_in_prefix": "ac8370aedf5fe3fe1e80710ce117dee23815be377d418e4b4f3259a1930e8dbf",
+        "size_in_bytes": 369
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Pyongyang",
+        "path_type": "hardlink",
+        "sha256": "29ba17f756f5c0bba30febf44e620504d04921c832bd1cb56e1b60ef288b57df",
+        "sha256_in_prefix": "29ba17f756f5c0bba30febf44e620504d04921c832bd1cb56e1b60ef288b57df",
+        "size_in_bytes": 273
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Qatar",
+        "path_type": "hardlink",
+        "sha256": "18cca69f933795ce3f7db31506efc063e6ce1dfdcab32aa387c398456d7f7e1f",
+        "sha256_in_prefix": "18cca69f933795ce3f7db31506efc063e6ce1dfdcab32aa387c398456d7f7e1f",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Qostanay",
+        "path_type": "hardlink",
+        "sha256": "4191629b874c988291e8fd13e675a3ed685d677f6541313975fc4610e47f1dcd",
+        "sha256_in_prefix": "4191629b874c988291e8fd13e675a3ed685d677f6541313975fc4610e47f1dcd",
+        "size_in_bytes": 1668
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Qyzylorda",
+        "path_type": "hardlink",
+        "sha256": "cd6b067aa3ef6935b4e89ca36e6a03fcb97f1e0ee61a7b5d46c06bf4de140774",
+        "sha256_in_prefix": "cd6b067aa3ef6935b4e89ca36e6a03fcb97f1e0ee61a7b5d46c06bf4de140774",
+        "size_in_bytes": 1670
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Rangoon",
+        "path_type": "hardlink",
+        "sha256": "e4d2c38d8e7377a528291a88129cdac40ca4d40a5f1cd8adb98228527556906e",
+        "sha256_in_prefix": "e4d2c38d8e7377a528291a88129cdac40ca4d40a5f1cd8adb98228527556906e",
+        "size_in_bytes": 174
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Riyadh",
+        "path_type": "hardlink",
+        "sha256": "411e31d09ffa48e44169c42661ae2f7fc142460bcaa216837d8c4740983ca7bd",
+        "sha256_in_prefix": "411e31d09ffa48e44169c42661ae2f7fc142460bcaa216837d8c4740983ca7bd",
+        "size_in_bytes": 148
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Saigon",
+        "path_type": "hardlink",
+        "sha256": "c695981a0df691c3f4509999fbc52858adc75024cccbdefbe1094fed17e809e4",
+        "sha256_in_prefix": "c695981a0df691c3f4509999fbc52858adc75024cccbdefbe1094fed17e809e4",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Sakhalin",
+        "path_type": "hardlink",
+        "sha256": "d7d0ea5cef908442ab0d777a4b097bed18540cd5280ff63f33dd989e27e72908",
+        "sha256_in_prefix": "d7d0ea5cef908442ab0d777a4b097bed18540cd5280ff63f33dd989e27e72908",
+        "size_in_bytes": 2117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Samarkand",
+        "path_type": "hardlink",
+        "sha256": "35e4b905723891281d9a6a0a1fd3760a3a48136e1419c686be31ace83bf7aa9d",
+        "sha256_in_prefix": "35e4b905723891281d9a6a0a1fd3760a3a48136e1419c686be31ace83bf7aa9d",
+        "size_in_bytes": 879
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Seoul",
+        "path_type": "hardlink",
+        "sha256": "c4f82c94650572fe4d03bc1fe54ced8f4bf55dfbee855d52de3ea6378240af93",
+        "sha256_in_prefix": "c4f82c94650572fe4d03bc1fe54ced8f4bf55dfbee855d52de3ea6378240af93",
+        "size_in_bytes": 985
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Shanghai",
+        "path_type": "hardlink",
+        "sha256": "3aabb42d9efe95d906b7f34640e7815919a1a20979ebb6ec1527fcaa3b09b22a",
+        "sha256_in_prefix": "3aabb42d9efe95d906b7f34640e7815919a1a20979ebb6ec1527fcaa3b09b22a",
+        "size_in_bytes": 981
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Singapore",
+        "path_type": "hardlink",
+        "sha256": "05c76b58a4e356fd358e24fbc71fae98dcb18c441c8d8cbb13a18d4f6e406062",
+        "sha256_in_prefix": "05c76b58a4e356fd358e24fbc71fae98dcb18c441c8d8cbb13a18d4f6e406062",
+        "size_in_bytes": 372
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Srednekolymsk",
+        "path_type": "hardlink",
+        "sha256": "705d6d8360c2dcd51e909e39e1910fe876145220d151031612da36b247207395",
+        "sha256_in_prefix": "705d6d8360c2dcd51e909e39e1910fe876145220d151031612da36b247207395",
+        "size_in_bytes": 2064
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Taipei",
+        "path_type": "hardlink",
+        "sha256": "389c9d3ee2970665d0d8c5cb61b8b790c5fbddc0df0bf2b9753046f5953a477f",
+        "sha256_in_prefix": "389c9d3ee2970665d0d8c5cb61b8b790c5fbddc0df0bf2b9753046f5953a477f",
+        "size_in_bytes": 1344
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Tashkent",
+        "path_type": "hardlink",
+        "sha256": "4445f3f892c7267a6867009cc1a3f0b0548d0240408375a9d15360b28993c2a9",
+        "sha256_in_prefix": "4445f3f892c7267a6867009cc1a3f0b0548d0240408375a9d15360b28993c2a9",
+        "size_in_bytes": 878
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Tbilisi",
+        "path_type": "hardlink",
+        "sha256": "b637bb0e49144c717e99e93540cb2c4d3695d63b91fe42547f2f0aa006498693",
+        "sha256_in_prefix": "b637bb0e49144c717e99e93540cb2c4d3695d63b91fe42547f2f0aa006498693",
+        "size_in_bytes": 1729
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Tehran",
+        "path_type": "hardlink",
+        "sha256": "a78655218a749f4abca436be818e84d3277220ff3e69be20a786aadf8ac744f9",
+        "sha256_in_prefix": "a78655218a749f4abca436be818e84d3277220ff3e69be20a786aadf8ac744f9",
+        "size_in_bytes": 7250
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Tel_Aviv",
+        "path_type": "hardlink",
+        "sha256": "07537a30e6236d9e334dafd5c4d352d25fdef95d6dc7496f5d93efab74d9ebb1",
+        "sha256_in_prefix": "07537a30e6236d9e334dafd5c4d352d25fdef95d6dc7496f5d93efab74d9ebb1",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Thimbu",
+        "path_type": "hardlink",
+        "sha256": "37459c17b59639df62b3f3943751902ce6aaf1f11b7630069db45052ebefb5b9",
+        "sha256_in_prefix": "37459c17b59639df62b3f3943751902ce6aaf1f11b7630069db45052ebefb5b9",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Thimphu",
+        "path_type": "hardlink",
+        "sha256": "b797c74e3840298c3cd8149fc8aa4bce839efe79e7c3310986ff23c965607929",
+        "sha256_in_prefix": "b797c74e3840298c3cd8149fc8aa4bce839efe79e7c3310986ff23c965607929",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Tokyo",
+        "path_type": "hardlink",
+        "sha256": "3da522fa88541a375d53f30a0b62dc4a305fa0315fee534b7998c9e0a239450a",
+        "sha256_in_prefix": "3da522fa88541a375d53f30a0b62dc4a305fa0315fee534b7998c9e0a239450a",
+        "size_in_bytes": 388
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Tomsk",
+        "path_type": "hardlink",
+        "sha256": "6b64a01d0f0b5ec7a1410c3bd6883ba7cc133e9f073d40e8bfece037e3a3fa24",
+        "sha256_in_prefix": "6b64a01d0f0b5ec7a1410c3bd6883ba7cc133e9f073d40e8bfece037e3a3fa24",
+        "size_in_bytes": 2116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Ujung_Pandang",
+        "path_type": "hardlink",
+        "sha256": "732751845acedbffd3c6170f4b94cb20b25bfdcfcc5eea19f4be439f5c5b573a",
+        "sha256_in_prefix": "732751845acedbffd3c6170f4b94cb20b25bfdcfcc5eea19f4be439f5c5b573a",
+        "size_in_bytes": 186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Ulaanbaatar",
+        "path_type": "hardlink",
+        "sha256": "a56a26981163a717cf388a423cfe7a2bad1be8652be2e338670cbc0c0a70e5e9",
+        "sha256_in_prefix": "a56a26981163a717cf388a423cfe7a2bad1be8652be2e338670cbc0c0a70e5e9",
+        "size_in_bytes": 1590
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Ulan_Bator",
+        "path_type": "hardlink",
+        "sha256": "d17fdaf17b3dac3a1310e2332f61585598185e64ced799abd68249eb5b698591",
+        "sha256_in_prefix": "d17fdaf17b3dac3a1310e2332f61585598185e64ced799abd68249eb5b698591",
+        "size_in_bytes": 192
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Urumqi",
+        "path_type": "hardlink",
+        "sha256": "c445b8030deddded0aff5cc692cc323b63be8c14bbd42dc3fde90ad4f9d14785",
+        "sha256_in_prefix": "c445b8030deddded0aff5cc692cc323b63be8c14bbd42dc3fde90ad4f9d14785",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Ust-Nera",
+        "path_type": "hardlink",
+        "sha256": "9d639c0fc69b3beebc96969092f9590eb48e7946e901b225bf245e165973b9a8",
+        "sha256_in_prefix": "9d639c0fc69b3beebc96969092f9590eb48e7946e901b225bf245e165973b9a8",
+        "size_in_bytes": 2058
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Vientiane",
+        "path_type": "hardlink",
+        "sha256": "18f5e4fe8247f676278ac5f1912ac401dc48df5b756d22e76ff1cfa702f88da7",
+        "sha256_in_prefix": "18f5e4fe8247f676278ac5f1912ac401dc48df5b756d22e76ff1cfa702f88da7",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Vladivostok",
+        "path_type": "hardlink",
+        "sha256": "2558c96e25359c72f168dac6fb3c16c54f8fd7d0724eeb1671156d4a1f42ac6c",
+        "sha256_in_prefix": "2558c96e25359c72f168dac6fb3c16c54f8fd7d0724eeb1671156d4a1f42ac6c",
+        "size_in_bytes": 2062
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Yakutsk",
+        "path_type": "hardlink",
+        "sha256": "3bef13638c46f16435d326c675907e61bb68c8173153ced3359e983be0e413e5",
+        "sha256_in_prefix": "3bef13638c46f16435d326c675907e61bb68c8173153ced3359e983be0e413e5",
+        "size_in_bytes": 2058
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Yangon",
+        "path_type": "hardlink",
+        "sha256": "2526557810747e78e713ae09bc305621a80faeecf8d441632e7825738d4c79cb",
+        "sha256_in_prefix": "2526557810747e78e713ae09bc305621a80faeecf8d441632e7825738d4c79cb",
+        "size_in_bytes": 244
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Yekaterinburg",
+        "path_type": "hardlink",
+        "sha256": "2c78699efc60758b8f8d0d1deedfded5e65c65ebf3082b23e60bdea8bf8fbcfe",
+        "sha256_in_prefix": "2c78699efc60758b8f8d0d1deedfded5e65c65ebf3082b23e60bdea8bf8fbcfe",
+        "size_in_bytes": 2095
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Asia/Yerevan",
+        "path_type": "hardlink",
+        "sha256": "20871fa6aa959ddfb73d846271b4a568627b564cfc08a11bdd84b98c2f2019a3",
+        "sha256_in_prefix": "20871fa6aa959ddfb73d846271b4a568627b564cfc08a11bdd84b98c2f2019a3",
+        "size_in_bytes": 2029
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Azores",
+        "path_type": "hardlink",
+        "sha256": "6b3609be4e93d21a2ab492594edd387931e2c787e8471c9f2d3a677f34002d8f",
+        "sha256_in_prefix": "6b3609be4e93d21a2ab492594edd387931e2c787e8471c9f2d3a677f34002d8f",
+        "size_in_bytes": 9879
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Bermuda",
+        "path_type": "hardlink",
+        "sha256": "099c3befba3b4c00ae19bc53d475a52b32fac9b36ec823c8eaefc7d00f78f388",
+        "sha256_in_prefix": "099c3befba3b4c00ae19bc53d475a52b32fac9b36ec823c8eaefc7d00f78f388",
+        "size_in_bytes": 8784
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Canary",
+        "path_type": "hardlink",
+        "sha256": "2026944dcdebc52f64405e35119f4cf97ea9aa1e769498730880b03f29a2b885",
+        "sha256_in_prefix": "2026944dcdebc52f64405e35119f4cf97ea9aa1e769498730880b03f29a2b885",
+        "size_in_bytes": 6856
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Cape_Verde",
+        "path_type": "hardlink",
+        "sha256": "2ea59acdb5bbdd3c6abceea456838a5ca57371a3d2bb93604b37f998ed8b9d4d",
+        "sha256_in_prefix": "2ea59acdb5bbdd3c6abceea456838a5ca57371a3d2bb93604b37f998ed8b9d4d",
+        "size_in_bytes": 246
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Faeroe",
+        "path_type": "hardlink",
+        "sha256": "64fb8cad17cd36666c7027aad01344fef659b13699eef1942365842f8ed2170e",
+        "sha256_in_prefix": "64fb8cad17cd36666c7027aad01344fef659b13699eef1942365842f8ed2170e",
+        "size_in_bytes": 186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Faroe",
+        "path_type": "hardlink",
+        "sha256": "795f438e7f01342d5f25eccdd09fce65c03c5d2d561b9b5191301d57ec16b850",
+        "sha256_in_prefix": "795f438e7f01342d5f25eccdd09fce65c03c5d2d561b9b5191301d57ec16b850",
+        "size_in_bytes": 6796
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Jan_Mayen",
+        "path_type": "hardlink",
+        "sha256": "9152d10450cebce4aaea3f3c8a50e4077a881e0b06b193a5886f06a453803112",
+        "sha256_in_prefix": "9152d10450cebce4aaea3f3c8a50e4077a881e0b06b193a5886f06a453803112",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Madeira",
+        "path_type": "hardlink",
+        "sha256": "b2a0d0ddc26806a05b2be806ca3f938db12a3fa40110b8b21fd3f04efed3a531",
+        "sha256_in_prefix": "b2a0d0ddc26806a05b2be806ca3f938db12a3fa40110b8b21fd3f04efed3a531",
+        "size_in_bytes": 9709
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Reykjavik",
+        "path_type": "hardlink",
+        "sha256": "e77b9d50af6c2550ca0517b4a6de64a8a159ad0c77f1294c4212b6e20221b099",
+        "sha256_in_prefix": "e77b9d50af6c2550ca0517b4a6de64a8a159ad0c77f1294c4212b6e20221b099",
+        "size_in_bytes": 2035
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/South_Georgia",
+        "path_type": "hardlink",
+        "sha256": "51bfabcb3388107753a3c1a8cf31118e6627132baa09b9878d9e7cedbebb4886",
+        "sha256_in_prefix": "51bfabcb3388107753a3c1a8cf31118e6627132baa09b9878d9e7cedbebb4886",
+        "size_in_bytes": 160
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/St_Helena",
+        "path_type": "hardlink",
+        "sha256": "1c9ca8966fc8bd0be70f4a187e17e56fb99139bc88c392e82ba2e23e23111c54",
+        "sha256_in_prefix": "1c9ca8966fc8bd0be70f4a187e17e56fb99139bc88c392e82ba2e23e23111c54",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Atlantic/Stanley",
+        "path_type": "hardlink",
+        "sha256": "f0e99ef01f140cd5aafe16803a657922207e6f7f6af10b0ae795790916c302c4",
+        "sha256_in_prefix": "f0e99ef01f140cd5aafe16803a657922207e6f7f6af10b0ae795790916c302c4",
+        "size_in_bytes": 2256
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/ACT",
+        "path_type": "hardlink",
+        "sha256": "df7cbddcbb2f5926a07d19a35739e5b8dcd9733c037f7d1ff95753c28d574674",
+        "sha256_in_prefix": "df7cbddcbb2f5926a07d19a35739e5b8dcd9733c037f7d1ff95753c28d574674",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Adelaide",
+        "path_type": "hardlink",
+        "sha256": "5c43d3152982bcfd5b9f51d0e909cf3a558bed1c270feffe030531d38d6f91b7",
+        "sha256_in_prefix": "5c43d3152982bcfd5b9f51d0e909cf3a558bed1c270feffe030531d38d6f91b7",
+        "size_in_bytes": 8372
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Brisbane",
+        "path_type": "hardlink",
+        "sha256": "0d3c39edab34a8db31a658a1549772f7d69eb57565e40aa87b707953a2d854a4",
+        "sha256_in_prefix": "0d3c39edab34a8db31a658a1549772f7d69eb57565e40aa87b707953a2d854a4",
+        "size_in_bytes": 674
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Broken_Hill",
+        "path_type": "hardlink",
+        "sha256": "734f295bd0b558bdf6178de62151b8913699d08ab2b1d101c55b8debc410074c",
+        "sha256_in_prefix": "734f295bd0b558bdf6178de62151b8913699d08ab2b1d101c55b8debc410074c",
+        "size_in_bytes": 8437
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Canberra",
+        "path_type": "hardlink",
+        "sha256": "5fe3ced97293fe0573d5ece0cef59ce5ddb4c57bc568ae7199e77b01d3ade17c",
+        "sha256_in_prefix": "5fe3ced97293fe0573d5ece0cef59ce5ddb4c57bc568ae7199e77b01d3ade17c",
+        "size_in_bytes": 195
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Currie",
+        "path_type": "hardlink",
+        "sha256": "1dd4ec4ed4f854e2ef6162b2f28c89208710f8ec5aabb95ffa9425d3fbbcab13",
+        "sha256_in_prefix": "1dd4ec4ed4f854e2ef6162b2f28c89208710f8ec5aabb95ffa9425d3fbbcab13",
+        "size_in_bytes": 193
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Darwin",
+        "path_type": "hardlink",
+        "sha256": "ac004fd4b3c536406991ec13ebb3e64e0ec0c7b264bc18c0700c8fa545868155",
+        "sha256_in_prefix": "ac004fd4b3c536406991ec13ebb3e64e0ec0c7b264bc18c0700c8fa545868155",
+        "size_in_bytes": 437
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Eucla",
+        "path_type": "hardlink",
+        "sha256": "79d0c770a304360db33f3d1ef7b3935f1e4e8125893e0dce683ac35a51302cfb",
+        "sha256_in_prefix": "79d0c770a304360db33f3d1ef7b3935f1e4e8125893e0dce683ac35a51302cfb",
+        "size_in_bytes": 759
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Hobart",
+        "path_type": "hardlink",
+        "sha256": "d813f6a97befc22ca4f24c59eb755d269b9c68a449cc7cf0d2c61f911860ebe7",
+        "sha256_in_prefix": "d813f6a97befc22ca4f24c59eb755d269b9c68a449cc7cf0d2c61f911860ebe7",
+        "size_in_bytes": 8734
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/LHI",
+        "path_type": "hardlink",
+        "sha256": "4d84e4040fbc529c9e0366bb74d0cfadeeeeda0dfcc6c2c9204ded6c6455cac3",
+        "sha256_in_prefix": "4d84e4040fbc529c9e0366bb74d0cfadeeeeda0dfcc6c2c9204ded6c6455cac3",
+        "size_in_bytes": 199
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Lindeman",
+        "path_type": "hardlink",
+        "sha256": "01b278309353849cc2fdf62a30e2ff483833d5713cf5e329252738be6f2c0a84",
+        "sha256_in_prefix": "01b278309353849cc2fdf62a30e2ff483833d5713cf5e329252738be6f2c0a84",
+        "size_in_bytes": 824
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Lord_Howe",
+        "path_type": "hardlink",
+        "sha256": "76d1f1ed67b8f8d6903789c2fddf79590a83677972d416f5f3c9687614ec6238",
+        "sha256_in_prefix": "76d1f1ed67b8f8d6903789c2fddf79590a83677972d416f5f3c9687614ec6238",
+        "size_in_bytes": 7764
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Melbourne",
+        "path_type": "hardlink",
+        "sha256": "f21b9ea51c0d41bad0420fe0601e5a4b491fb895856f4bddf6541d704469d92f",
+        "sha256_in_prefix": "f21b9ea51c0d41bad0420fe0601e5a4b491fb895856f4bddf6541d704469d92f",
+        "size_in_bytes": 8341
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/NSW",
+        "path_type": "hardlink",
+        "sha256": "73d7c9e207e61acf8df7242bdcd84488189033e22a84873a953b65de02fa1b0b",
+        "sha256_in_prefix": "73d7c9e207e61acf8df7242bdcd84488189033e22a84873a953b65de02fa1b0b",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/North",
+        "path_type": "hardlink",
+        "sha256": "a983c9cad7e542caed43b083e68cd2b782959a4b54015f374c29250d3acf9b8d",
+        "sha256_in_prefix": "a983c9cad7e542caed43b083e68cd2b782959a4b54015f374c29250d3acf9b8d",
+        "size_in_bytes": 192
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Perth",
+        "path_type": "hardlink",
+        "sha256": "fc1b54ca261074e47a8a486feac12dd04d46166d1d2b44163bd8791bec32d275",
+        "sha256_in_prefix": "fc1b54ca261074e47a8a486feac12dd04d46166d1d2b44163bd8791bec32d275",
+        "size_in_bytes": 739
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Queensland",
+        "path_type": "hardlink",
+        "sha256": "dda669b9bfb3e08fc23ce67030148b9e4740824add8de02580d6afd31ce05bab",
+        "sha256_in_prefix": "dda669b9bfb3e08fc23ce67030148b9e4740824add8de02580d6afd31ce05bab",
+        "size_in_bytes": 203
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/South",
+        "path_type": "hardlink",
+        "sha256": "d9dcfdc377901ec0c0feb9cea743c2c1425273f69a1baa7bf3b74fec5885b267",
+        "sha256_in_prefix": "d9dcfdc377901ec0c0feb9cea743c2c1425273f69a1baa7bf3b74fec5885b267",
+        "size_in_bytes": 198
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Sydney",
+        "path_type": "hardlink",
+        "sha256": "fc453486325ade1d31f14087b76d4936f3a6d551abd1db6fcac129bdb043951c",
+        "sha256_in_prefix": "fc453486325ade1d31f14087b76d4936f3a6d551abd1db6fcac129bdb043951c",
+        "size_in_bytes": 8338
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Tasmania",
+        "path_type": "hardlink",
+        "sha256": "c94fa7a7640cd00963ee8ff1a3d9dcda2075408739d998edbf7cfc998db764fd",
+        "sha256_in_prefix": "c94fa7a7640cd00963ee8ff1a3d9dcda2075408739d998edbf7cfc998db764fd",
+        "size_in_bytes": 195
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Victoria",
+        "path_type": "hardlink",
+        "sha256": "dbef9c5bdd290fec5fa740d697143332d3ca1fc373cf1df736f1883ac9ba3298",
+        "sha256_in_prefix": "dbef9c5bdd290fec5fa740d697143332d3ca1fc373cf1df736f1883ac9ba3298",
+        "size_in_bytes": 204
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/West",
+        "path_type": "hardlink",
+        "sha256": "75abb7f20c4a0b618138aa190af33ceaf2a6d2c707da6c1314e4bff2f9904f58",
+        "sha256_in_prefix": "75abb7f20c4a0b618138aa190af33ceaf2a6d2c707da6c1314e4bff2f9904f58",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Australia/Yancowinna",
+        "path_type": "hardlink",
+        "sha256": "55a9264d0414644a1be342106ae86086a6659596dc9322a74fc4d1ddb41f7c60",
+        "sha256_in_prefix": "55a9264d0414644a1be342106ae86086a6659596dc9322a74fc4d1ddb41f7c60",
+        "size_in_bytes": 212
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Brazil/Acre",
+        "path_type": "hardlink",
+        "sha256": "2f594239a434052d36053a2b3eab134eadbad06eb6737e67cf72166dab157537",
+        "sha256_in_prefix": "2f594239a434052d36053a2b3eab134eadbad06eb6737e67cf72166dab157537",
+        "size_in_bytes": 194
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Brazil/DeNoronha",
+        "path_type": "hardlink",
+        "sha256": "a676562a90ff8587a775f6f0e3be05d870456a56d25b5330816bf9043c8d475b",
+        "sha256_in_prefix": "a676562a90ff8587a775f6f0e3be05d870456a56d25b5330816bf9043c8d475b",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Brazil/East",
+        "path_type": "hardlink",
+        "sha256": "961fb3ab99a63b1e9704b737eab2d588b5a39d253a213e175cc678bedffd498d",
+        "sha256_in_prefix": "961fb3ab99a63b1e9704b737eab2d588b5a39d253a213e175cc678bedffd498d",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Brazil/West",
+        "path_type": "hardlink",
+        "sha256": "0500c9a248c8ce9030ea30d0af9dd95dc465480baf60646c0b7c511fa23c6d1f",
+        "sha256_in_prefix": "0500c9a248c8ce9030ea30d0af9dd95dc465480baf60646c0b7c511fa23c6d1f",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/CET",
+        "path_type": "hardlink",
+        "sha256": "e2aea7cfd428a43d9db938bcc476623adc1250bd8057013a7fff5f89d7ff8efc",
+        "sha256_in_prefix": "e2aea7cfd428a43d9db938bcc476623adc1250bd8057013a7fff5f89d7ff8efc",
+        "size_in_bytes": 7736
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/CST6CDT",
+        "path_type": "hardlink",
+        "sha256": "73a9841f233aa657afb6ced8a86a37d55fe5582dd996b9b28975d218bccc078f",
+        "sha256_in_prefix": "73a9841f233aa657afb6ced8a86a37d55fe5582dd996b9b28975d218bccc078f",
+        "size_in_bytes": 8505
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Canada/Atlantic",
+        "path_type": "hardlink",
+        "sha256": "6dc6354d761cbe7820c9186568cab87ad48ca925507f6a740357195b60e16d87",
+        "sha256_in_prefix": "6dc6354d761cbe7820c9186568cab87ad48ca925507f6a740357195b60e16d87",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Canada/Central",
+        "path_type": "hardlink",
+        "sha256": "db32e83949d62478d229e9fb57bb1624d21b3a9ccee4cd55335f8262c01d820a",
+        "sha256_in_prefix": "db32e83949d62478d229e9fb57bb1624d21b3a9ccee4cd55335f8262c01d820a",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Canada/East-Saskatchewan",
+        "path_type": "hardlink",
+        "sha256": "27cceb515f9b2ab2d441f7c1533064ad13c89a6a009c3f2f14842b217075e231",
+        "sha256_in_prefix": "27cceb515f9b2ab2d441f7c1533064ad13c89a6a009c3f2f14842b217075e231",
+        "size_in_bytes": 195
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Canada/Eastern",
+        "path_type": "hardlink",
+        "sha256": "22844994ae893f3236a091b050e932e84a5218ec0d01f72595e17ccc471fa564",
+        "sha256_in_prefix": "22844994ae893f3236a091b050e932e84a5218ec0d01f72595e17ccc471fa564",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Canada/Mountain",
+        "path_type": "hardlink",
+        "sha256": "d7a203e60ff19dcdeaad14121720de51da73392d25b40ffa301c1935cdf89517",
+        "sha256_in_prefix": "d7a203e60ff19dcdeaad14121720de51da73392d25b40ffa301c1935cdf89517",
+        "size_in_bytes": 192
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Canada/Newfoundland",
+        "path_type": "hardlink",
+        "sha256": "87f42f45fd7d059ca47650d445420de8320f3a7c1cbc7671fbfa8a8881274433",
+        "sha256_in_prefix": "87f42f45fd7d059ca47650d445420de8320f3a7c1cbc7671fbfa8a8881274433",
+        "size_in_bytes": 196
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Canada/Pacific",
+        "path_type": "hardlink",
+        "sha256": "5c4fd46054b190a6d4b92585b4dae4e3a8233ee2996d14472835ddd264911dc6",
+        "sha256_in_prefix": "5c4fd46054b190a6d4b92585b4dae4e3a8233ee2996d14472835ddd264911dc6",
+        "size_in_bytes": 194
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Canada/Saskatchewan",
+        "path_type": "hardlink",
+        "sha256": "46ba00ae3a07a4dc83d6cb517d87c9cbba491b3421fe9ad6c74cac5695eb73f7",
+        "sha256_in_prefix": "46ba00ae3a07a4dc83d6cb517d87c9cbba491b3421fe9ad6c74cac5695eb73f7",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Canada/Yukon",
+        "path_type": "hardlink",
+        "sha256": "a1b1af37dc89c6ba663e4e967a18409ae4e0fa9ef1b908d0461368da31001c09",
+        "sha256_in_prefix": "a1b1af37dc89c6ba663e4e967a18409ae4e0fa9ef1b908d0461368da31001c09",
+        "size_in_bytes": 195
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Chile/Continental",
+        "path_type": "hardlink",
+        "sha256": "5b40167dd0c0b5c293861070c4ac249f78ddf8bad798dd0165e3ae894c9b9570",
+        "sha256_in_prefix": "5b40167dd0c0b5c293861070c4ac249f78ddf8bad798dd0165e3ae894c9b9570",
+        "size_in_bytes": 194
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Chile/EasterIsland",
+        "path_type": "hardlink",
+        "sha256": "1e2da1862e0e0f131b7c6eb12fac5f920852c61c162993a30bc843a464a5aad4",
+        "sha256_in_prefix": "1e2da1862e0e0f131b7c6eb12fac5f920852c61c162993a30bc843a464a5aad4",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Cuba",
+        "path_type": "hardlink",
+        "sha256": "6f4f2d7f5bca4e5183460c0153d2b98f5239a99f149de6638b311c73cedb1329",
+        "sha256_in_prefix": "6f4f2d7f5bca4e5183460c0153d2b98f5239a99f149de6638b311c73cedb1329",
+        "size_in_bytes": 175
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/EET",
+        "path_type": "hardlink",
+        "sha256": "64e284f9f7a36cc0a352809141d76e73a99344a9f30cffea254cbb9d2c589ada",
+        "sha256_in_prefix": "64e284f9f7a36cc0a352809141d76e73a99344a9f30cffea254cbb9d2c589ada",
+        "size_in_bytes": 7440
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/EST",
+        "path_type": "hardlink",
+        "sha256": "6344be02529c1cc5f7b5fe14b7e9bbced4dde68a24b824601eebcae207abfdf2",
+        "sha256_in_prefix": "6344be02529c1cc5f7b5fe14b7e9bbced4dde68a24b824601eebcae207abfdf2",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/EST5EDT",
+        "path_type": "hardlink",
+        "sha256": "0be6161403bc5a96bfab174f2c3fcba8a677d4349699b408e9872b9dd0fe15ce",
+        "sha256_in_prefix": "0be6161403bc5a96bfab174f2c3fcba8a677d4349699b408e9872b9dd0fe15ce",
+        "size_in_bytes": 8505
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Egypt",
+        "path_type": "hardlink",
+        "sha256": "936b6484469351def8fafe8ec180862729f5e43bde4e53e2e9636e221b54c3c2",
+        "sha256_in_prefix": "936b6484469351def8fafe8ec180862729f5e43bde4e53e2e9636e221b54c3c2",
+        "size_in_bytes": 170
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Eire",
+        "path_type": "hardlink",
+        "sha256": "b78a833337efec8b5f64622f1bfda21fcb79cf290e9cf32a54b206eb20c6fde9",
+        "sha256_in_prefix": "b78a833337efec8b5f64622f1bfda21fcb79cf290e9cf32a54b206eb20c6fde9",
+        "size_in_bytes": 172
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT",
+        "path_type": "hardlink",
+        "sha256": "66b0df8888883bff44b18728b48cdf24aaed0bb745d601f3422c4f2d4063e0ac",
+        "sha256_in_prefix": "66b0df8888883bff44b18728b48cdf24aaed0bb745d601f3422c4f2d4063e0ac",
+        "size_in_bytes": 110
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+0",
+        "path_type": "hardlink",
+        "sha256": "64466ea3759301e88c29ad1a833cdcbbc495eb4a5a3ac45e7b2987fecd6702bd",
+        "sha256_in_prefix": "64466ea3759301e88c29ad1a833cdcbbc495eb4a5a3ac45e7b2987fecd6702bd",
+        "size_in_bytes": 159
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+1",
+        "path_type": "hardlink",
+        "sha256": "3be1ec71d2cc88fa9a3db7dc0476475f33fe5bcbe6bc35c0f083859766466c32",
+        "sha256_in_prefix": "3be1ec71d2cc88fa9a3db7dc0476475f33fe5bcbe6bc35c0f083859766466c32",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+10",
+        "path_type": "hardlink",
+        "sha256": "e61e826e6fbc2396ef152640698098f4477d4ffdfe5f791f62250c3ec5865304",
+        "sha256_in_prefix": "e61e826e6fbc2396ef152640698098f4477d4ffdfe5f791f62250c3ec5865304",
+        "size_in_bytes": 118
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+11",
+        "path_type": "hardlink",
+        "sha256": "143528946275ddc8b894218d3f1be56c950f740828cec13166c3d7e8e1b6bb7e",
+        "sha256_in_prefix": "143528946275ddc8b894218d3f1be56c950f740828cec13166c3d7e8e1b6bb7e",
+        "size_in_bytes": 118
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+12",
+        "path_type": "hardlink",
+        "sha256": "a93eafac2c1089c608c8536127d0e8b53d8c7cfd13ae7dd69339e12a89f803c6",
+        "sha256_in_prefix": "a93eafac2c1089c608c8536127d0e8b53d8c7cfd13ae7dd69339e12a89f803c6",
+        "size_in_bytes": 118
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+2",
+        "path_type": "hardlink",
+        "sha256": "ad5833153446960bde0653a22ae2111bf80cfd61c3010993ce87b81d40c75c72",
+        "sha256_in_prefix": "ad5833153446960bde0653a22ae2111bf80cfd61c3010993ce87b81d40c75c72",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+3",
+        "path_type": "hardlink",
+        "sha256": "c7bee4c71905eddb40baf42c0cd0dc70bb9f298eaab8b9367d484b8431dd084a",
+        "sha256_in_prefix": "c7bee4c71905eddb40baf42c0cd0dc70bb9f298eaab8b9367d484b8431dd084a",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+4",
+        "path_type": "hardlink",
+        "sha256": "26d1ef512cc5797fc63ba2b83c7d6271025f4d4f5c904d9fa8e97f053393d9a7",
+        "sha256_in_prefix": "26d1ef512cc5797fc63ba2b83c7d6271025f4d4f5c904d9fa8e97f053393d9a7",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+5",
+        "path_type": "hardlink",
+        "sha256": "054910bddfc44d9b806bbd3008c30547fa57ecd3c043418c406a725158144688",
+        "sha256_in_prefix": "054910bddfc44d9b806bbd3008c30547fa57ecd3c043418c406a725158144688",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+6",
+        "path_type": "hardlink",
+        "sha256": "d53bb247e0e429a6243ab9a9bdcae1ee1cf5f271d79748a843631906ab63a988",
+        "sha256_in_prefix": "d53bb247e0e429a6243ab9a9bdcae1ee1cf5f271d79748a843631906ab63a988",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+7",
+        "path_type": "hardlink",
+        "sha256": "6ba5779e35d581b409f53b14b6e28ecc16f536ffedd45ddbc8dae4b8c28f66e7",
+        "sha256_in_prefix": "6ba5779e35d581b409f53b14b6e28ecc16f536ffedd45ddbc8dae4b8c28f66e7",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+8",
+        "path_type": "hardlink",
+        "sha256": "ca87559b154b165e83482aee3d753ba8e38abca347a005e8504c566433cf4cb3",
+        "sha256_in_prefix": "ca87559b154b165e83482aee3d753ba8e38abca347a005e8504c566433cf4cb3",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT+9",
+        "path_type": "hardlink",
+        "sha256": "a0987a1d078b0993fb3b07208e3f4538a2319dcdddeb2faea32fc463deafb8db",
+        "sha256_in_prefix": "a0987a1d078b0993fb3b07208e3f4538a2319dcdddeb2faea32fc463deafb8db",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-0",
+        "path_type": "hardlink",
+        "sha256": "eff27b3dee9306641ff344801e06bb33ff768cdccfe2409fa8af752ff6d39f66",
+        "sha256_in_prefix": "eff27b3dee9306641ff344801e06bb33ff768cdccfe2409fa8af752ff6d39f66",
+        "size_in_bytes": 159
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-1",
+        "path_type": "hardlink",
+        "sha256": "b4bf883fbe9246ef4079179a746b1f9e59f2c77d4f598794b60732d198dc6044",
+        "sha256_in_prefix": "b4bf883fbe9246ef4079179a746b1f9e59f2c77d4f598794b60732d198dc6044",
+        "size_in_bytes": 115
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-10",
+        "path_type": "hardlink",
+        "sha256": "ef3046d7789cae069b5473d053f3ef0157248f8a359a1282ee02ba613a75fc94",
+        "sha256_in_prefix": "ef3046d7789cae069b5473d053f3ef0157248f8a359a1282ee02ba613a75fc94",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-11",
+        "path_type": "hardlink",
+        "sha256": "ccdeadbd18be81e59a669a460a14afcbff733c3a5d164fc2b6b93deaf009b78a",
+        "sha256_in_prefix": "ccdeadbd18be81e59a669a460a14afcbff733c3a5d164fc2b6b93deaf009b78a",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-12",
+        "path_type": "hardlink",
+        "sha256": "23b61b18c653e25f7245b0bb6e04ad347e038585b145962fd1eeace26f118d54",
+        "sha256_in_prefix": "23b61b18c653e25f7245b0bb6e04ad347e038585b145962fd1eeace26f118d54",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-13",
+        "path_type": "hardlink",
+        "sha256": "a9f1ad5a7cb5ed43c5e6e8a7a9b887329890abb75b9fc9483b8543a367457ebe",
+        "sha256_in_prefix": "a9f1ad5a7cb5ed43c5e6e8a7a9b887329890abb75b9fc9483b8543a367457ebe",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-14",
+        "path_type": "hardlink",
+        "sha256": "a37a7160027bd38356764c4d1aa5b9b17f8d5dc3cfb81ef2ed399e44c41734ce",
+        "sha256_in_prefix": "a37a7160027bd38356764c4d1aa5b9b17f8d5dc3cfb81ef2ed399e44c41734ce",
+        "size_in_bytes": 117
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-2",
+        "path_type": "hardlink",
+        "sha256": "7211bf8329b2388563ed8fa8c5140099a171b8a303a9473e9a6f3af0c5d239cb",
+        "sha256_in_prefix": "7211bf8329b2388563ed8fa8c5140099a171b8a303a9473e9a6f3af0c5d239cb",
+        "size_in_bytes": 115
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-3",
+        "path_type": "hardlink",
+        "sha256": "bfc86d65b0b94725dce4c88edc4300141abbca4b6cdecf037c437df49f0c1d6a",
+        "sha256_in_prefix": "bfc86d65b0b94725dce4c88edc4300141abbca4b6cdecf037c437df49f0c1d6a",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-4",
+        "path_type": "hardlink",
+        "sha256": "02e2eeaf88ee179ef63dd29acc7384a4b46de1e3a151c1f3a5dd31bbb5a05aee",
+        "sha256_in_prefix": "02e2eeaf88ee179ef63dd29acc7384a4b46de1e3a151c1f3a5dd31bbb5a05aee",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-5",
+        "path_type": "hardlink",
+        "sha256": "3a2c75dca11d1167126f0d44a8682420faf75b0b82b3dcfc35a9f028a9a759e8",
+        "sha256_in_prefix": "3a2c75dca11d1167126f0d44a8682420faf75b0b82b3dcfc35a9f028a9a759e8",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-6",
+        "path_type": "hardlink",
+        "sha256": "d22c87321373ec0efb0f312925476cd0747323ef303e17621a871bf814c8abb1",
+        "sha256_in_prefix": "d22c87321373ec0efb0f312925476cd0747323ef303e17621a871bf814c8abb1",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-7",
+        "path_type": "hardlink",
+        "sha256": "70cb3a766a2e84148b68613d68687d263d3592ed4b6e672797fb20801eca8231",
+        "sha256_in_prefix": "70cb3a766a2e84148b68613d68687d263d3592ed4b6e672797fb20801eca8231",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-8",
+        "path_type": "hardlink",
+        "sha256": "80c85d59416cec91db3dac5fdd2fd7b91d6fc74a37bbbef6ff58f6f6816e8fc9",
+        "sha256_in_prefix": "80c85d59416cec91db3dac5fdd2fd7b91d6fc74a37bbbef6ff58f6f6816e8fc9",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT-9",
+        "path_type": "hardlink",
+        "sha256": "57395bb968afa5a041eada4b684b82f0379a9333f9522d69f069a79fdea2b8d7",
+        "sha256_in_prefix": "57395bb968afa5a041eada4b684b82f0379a9333f9522d69f069a79fdea2b8d7",
+        "size_in_bytes": 116
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/GMT0",
+        "path_type": "hardlink",
+        "sha256": "ab742f93be44bd68ab8fe84505fa28120f1808765d9baed32a3490af7c83d35b",
+        "sha256_in_prefix": "ab742f93be44bd68ab8fe84505fa28120f1808765d9baed32a3490af7c83d35b",
+        "size_in_bytes": 158
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/Greenwich",
+        "path_type": "hardlink",
+        "sha256": "f89167b6117838d9679c0397496b6d96d3a7beaef0bd99406abacdbdb658fbcc",
+        "sha256_in_prefix": "f89167b6117838d9679c0397496b6d96d3a7beaef0bd99406abacdbdb658fbcc",
+        "size_in_bytes": 163
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/UCT",
+        "path_type": "hardlink",
+        "sha256": "0856d14dbbc53d46460bcd530bd070e9e8966d1c96ba01ba556e215a98c09cd4",
+        "sha256_in_prefix": "0856d14dbbc53d46460bcd530bd070e9e8966d1c96ba01ba556e215a98c09cd4",
+        "size_in_bytes": 157
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/UTC",
+        "path_type": "hardlink",
+        "sha256": "4d74d9ec2397b1708fef47806294b0bca26679f3a63149ae24e4e0c641976970",
+        "sha256_in_prefix": "4d74d9ec2397b1708fef47806294b0bca26679f3a63149ae24e4e0c641976970",
+        "size_in_bytes": 110
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/Universal",
+        "path_type": "hardlink",
+        "sha256": "a2b62c5914de169a68a018a5b47c1253dbca10a251862d17b0781ecfd19b6192",
+        "sha256_in_prefix": "a2b62c5914de169a68a018a5b47c1253dbca10a251862d17b0781ecfd19b6192",
+        "size_in_bytes": 163
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Etc/Zulu",
+        "path_type": "hardlink",
+        "sha256": "bbd6e93206ff3b7017afbe63905b4c932c422b582f3ce2a79a7b885d390ee555",
+        "sha256_in_prefix": "bbd6e93206ff3b7017afbe63905b4c932c422b582f3ce2a79a7b885d390ee555",
+        "size_in_bytes": 158
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Amsterdam",
+        "path_type": "hardlink",
+        "sha256": "5808f77cab37ed4f52f0a02ff0b75ea194f8799a2165695ca3650579cad498d9",
+        "sha256_in_prefix": "5808f77cab37ed4f52f0a02ff0b75ea194f8799a2165695ca3650579cad498d9",
+        "size_in_bytes": 9102
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Andorra",
+        "path_type": "hardlink",
+        "sha256": "f0b48da7ca3659450d87cc0ddfddfd28b464543df1ee40d935c44d5cd7c9b9b3",
+        "sha256_in_prefix": "f0b48da7ca3659450d87cc0ddfddfd28b464543df1ee40d935c44d5cd7c9b9b3",
+        "size_in_bytes": 6927
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Astrakhan",
+        "path_type": "hardlink",
+        "sha256": "4b5fb0af225974d117374028285f20a02b833ff4136e6bfae7b65e6d6d28829e",
+        "sha256_in_prefix": "4b5fb0af225974d117374028285f20a02b833ff4136e6bfae7b65e6d6d28829e",
+        "size_in_bytes": 2063
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Athens",
+        "path_type": "hardlink",
+        "sha256": "47353319419505aab205c23f8c97ea0b12e5ded2113147794f77b67349aff52f",
+        "sha256_in_prefix": "47353319419505aab205c23f8c97ea0b12e5ded2113147794f77b67349aff52f",
+        "size_in_bytes": 7954
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Belfast",
+        "path_type": "hardlink",
+        "sha256": "557023674f6e8376707517103ee69c1debbe53cdd4bcab11e763cc53b9cb1908",
+        "sha256_in_prefix": "557023674f6e8376707517103ee69c1debbe53cdd4bcab11e763cc53b9cb1908",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Belgrade",
+        "path_type": "hardlink",
+        "sha256": "74b225511b518b0ced972cbb33d694697712ccb96a6d81e0f50ada28cf6e2c92",
+        "sha256_in_prefix": "74b225511b518b0ced972cbb33d694697712ccb96a6d81e0f50ada28cf6e2c92",
+        "size_in_bytes": 7309
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Berlin",
+        "path_type": "hardlink",
+        "sha256": "7e7111f06288069b52a4e1ca0b016216df9328fb3b1560a740146497ccdd4d24",
+        "sha256_in_prefix": "7e7111f06288069b52a4e1ca0b016216df9328fb3b1560a740146497ccdd4d24",
+        "size_in_bytes": 8020
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Bratislava",
+        "path_type": "hardlink",
+        "sha256": "1d7c539aaa1e3ad5ef3574a629523b5b781f1a91d352c9b39b8de7316756026e",
+        "sha256_in_prefix": "1d7c539aaa1e3ad5ef3574a629523b5b781f1a91d352c9b39b8de7316756026e",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Brussels",
+        "path_type": "hardlink",
+        "sha256": "1402a2072adc9ebb35f4c0368d2e9a7a11493626c667c022614ffb7cc05b6cb6",
+        "sha256_in_prefix": "1402a2072adc9ebb35f4c0368d2e9a7a11493626c667c022614ffb7cc05b6cb6",
+        "size_in_bytes": 9223
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Bucharest",
+        "path_type": "hardlink",
+        "sha256": "c560d45104a8dd73fc7370b5ac1615e22043dbc93dfb46a9ecc6468c2d38b19a",
+        "sha256_in_prefix": "c560d45104a8dd73fc7370b5ac1615e22043dbc93dfb46a9ecc6468c2d38b19a",
+        "size_in_bytes": 7974
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Budapest",
+        "path_type": "hardlink",
+        "sha256": "b58f3e9066b8b57eb037d509636aa67a06acc8348be6c48482d87cdc49844a4e",
+        "sha256_in_prefix": "b58f3e9066b8b57eb037d509636aa67a06acc8348be6c48482d87cdc49844a4e",
+        "size_in_bytes": 8287
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Busingen",
+        "path_type": "hardlink",
+        "sha256": "f511a80ab70ff93a0eb9f29293f73df952b773bb33eb85d581e4fb1fe06e4f05",
+        "sha256_in_prefix": "f511a80ab70ff93a0eb9f29293f73df952b773bb33eb85d581e4fb1fe06e4f05",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Chisinau",
+        "path_type": "hardlink",
+        "sha256": "2bd1c0ab412a5e9c97f533c4d06b773d045215b92568a4e89adc93c7462d62ec",
+        "sha256_in_prefix": "2bd1c0ab412a5e9c97f533c4d06b773d045215b92568a4e89adc93c7462d62ec",
+        "size_in_bytes": 8096
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Copenhagen",
+        "path_type": "hardlink",
+        "sha256": "c6abc78ad0f03f903e04db41067b555f9e589e321e253a01ed819189c6fffc0e",
+        "sha256_in_prefix": "c6abc78ad0f03f903e04db41067b555f9e589e321e253a01ed819189c6fffc0e",
+        "size_in_bytes": 7722
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Dublin",
+        "path_type": "hardlink",
+        "sha256": "930f4e37b6d60b6701cba95eea1f6053d85e5f9de6bbe287a0d43e24b9d63fb0",
+        "sha256_in_prefix": "930f4e37b6d60b6701cba95eea1f6053d85e5f9de6bbe287a0d43e24b9d63fb0",
+        "size_in_bytes": 9810
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Gibraltar",
+        "path_type": "hardlink",
+        "sha256": "0524a31131405347c1d5d86c5ee38a2064ab055c030ab3b43f25db3b28ffd8d2",
+        "sha256_in_prefix": "0524a31131405347c1d5d86c5ee38a2064ab055c030ab3b43f25db3b28ffd8d2",
+        "size_in_bytes": 9509
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Guernsey",
+        "path_type": "hardlink",
+        "sha256": "f7046808a8e80b7ae449d1a49ae3e480096736b7d3f554a240c7dfb10f82076a",
+        "sha256_in_prefix": "f7046808a8e80b7ae449d1a49ae3e480096736b7d3f554a240c7dfb10f82076a",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Helsinki",
+        "path_type": "hardlink",
+        "sha256": "5b5c0a9261a414ea8dc34f594ee05bee16f695488b230857d2b569a6b603bc39",
+        "sha256_in_prefix": "5b5c0a9261a414ea8dc34f594ee05bee16f695488b230857d2b569a6b603bc39",
+        "size_in_bytes": 7368
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Isle_of_Man",
+        "path_type": "hardlink",
+        "sha256": "2f1151b0528a5325443379d4e7cce32c00213722ad9df764e1dc90198084b076",
+        "sha256_in_prefix": "2f1151b0528a5325443379d4e7cce32c00213722ad9df764e1dc90198084b076",
+        "size_in_bytes": 186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Istanbul",
+        "path_type": "hardlink",
+        "sha256": "08061a80fc0f1ef375eefe784eacdf0812e289fd67e8613bdec36209985ca1d7",
+        "sha256_in_prefix": "08061a80fc0f1ef375eefe784eacdf0812e289fd67e8613bdec36209985ca1d7",
+        "size_in_bytes": 3683
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Jersey",
+        "path_type": "hardlink",
+        "sha256": "97eb33915ed7c9c34144f8f42357fab2262b3cd45287f3cffd26c33d65f7651e",
+        "sha256_in_prefix": "97eb33915ed7c9c34144f8f42357fab2262b3cd45287f3cffd26c33d65f7651e",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Kaliningrad",
+        "path_type": "hardlink",
+        "sha256": "2387d26df5429df9867f42f7d4f872dc146643b4b3cc57da7298c18561de8bfe",
+        "sha256_in_prefix": "2387d26df5429df9867f42f7d4f872dc146643b4b3cc57da7298c18561de8bfe",
+        "size_in_bytes": 2512
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Kiev",
+        "path_type": "hardlink",
+        "sha256": "08b137b7b933393f8f4574615a370013288e5297937b5c59d4179744273fab26",
+        "sha256_in_prefix": "08b137b7b933393f8f4574615a370013288e5297937b5c59d4179744273fab26",
+        "size_in_bytes": 7453
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Kirov",
+        "path_type": "hardlink",
+        "sha256": "60884d4b8b17a9ab8fb5697da95f62e570755348109c661d783d56cd047bbe9e",
+        "sha256_in_prefix": "60884d4b8b17a9ab8fb5697da95f62e570755348109c661d783d56cd047bbe9e",
+        "size_in_bytes": 2029
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Lisbon",
+        "path_type": "hardlink",
+        "sha256": "9fac9812411f88014779d34722f3e0d2750e45bf21595df1ae14cb9ccfd3f33f",
+        "sha256_in_prefix": "9fac9812411f88014779d34722f3e0d2750e45bf21595df1ae14cb9ccfd3f33f",
+        "size_in_bytes": 9878
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Ljubljana",
+        "path_type": "hardlink",
+        "sha256": "713a842197516d618f2d86977262542a1ca334d7df6026539fa2f2980dbf4cd3",
+        "sha256_in_prefix": "713a842197516d618f2d86977262542a1ca334d7df6026539fa2f2980dbf4cd3",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/London",
+        "path_type": "hardlink",
+        "sha256": "d04c4e25df4de1c1cfe1ef84b3b6dd746cf08a271ab0958f22c7d580a3ed10e6",
+        "sha256_in_prefix": "d04c4e25df4de1c1cfe1ef84b3b6dd746cf08a271ab0958f22c7d580a3ed10e6",
+        "size_in_bytes": 10211
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Luxembourg",
+        "path_type": "hardlink",
+        "sha256": "380e49d38f6abe946a90a9343a277ed28492eb800747d6d14f4639fd3ea80ede",
+        "sha256_in_prefix": "380e49d38f6abe946a90a9343a277ed28492eb800747d6d14f4639fd3ea80ede",
+        "size_in_bytes": 9139
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Madrid",
+        "path_type": "hardlink",
+        "sha256": "5337c9843c56deec6b91c4468c76ec1c896e80421b72b583b69de5579063e09a",
+        "sha256_in_prefix": "5337c9843c56deec6b91c4468c76ec1c896e80421b72b583b69de5579063e09a",
+        "size_in_bytes": 8517
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Malta",
+        "path_type": "hardlink",
+        "sha256": "c5c240baaece8235d1fbdd251c1a67cb2d2fc8195dd5bbe37ff9cff0445fcda2",
+        "sha256_in_prefix": "c5c240baaece8235d1fbdd251c1a67cb2d2fc8195dd5bbe37ff9cff0445fcda2",
+        "size_in_bytes": 8724
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Mariehamn",
+        "path_type": "hardlink",
+        "sha256": "6136c3cfa4a767e7c9dda23a283ad98b72e9868f192e6a8e3bfe6396f6989bd1",
+        "sha256_in_prefix": "6136c3cfa4a767e7c9dda23a283ad98b72e9868f192e6a8e3bfe6396f6989bd1",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Minsk",
+        "path_type": "hardlink",
+        "sha256": "8c95ea696ea578def726502ac181af475a676030878f56b4e2d667757bbd1c49",
+        "sha256_in_prefix": "8c95ea696ea578def726502ac181af475a676030878f56b4e2d667757bbd1c49",
+        "size_in_bytes": 2177
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Monaco",
+        "path_type": "hardlink",
+        "sha256": "654b92e8b9e8fbdc967d094b48110908f458454d7057f680ac745b9c8d48fcc1",
+        "sha256_in_prefix": "654b92e8b9e8fbdc967d094b48110908f458454d7057f680ac745b9c8d48fcc1",
+        "size_in_bytes": 9186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Moscow",
+        "path_type": "hardlink",
+        "sha256": "31f9c3c2f17b3ee4fa6d9ee6a86bf407ac0377de4d666c65e86ce5ac591f829f",
+        "sha256_in_prefix": "31f9c3c2f17b3ee4fa6d9ee6a86bf407ac0377de4d666c65e86ce5ac591f829f",
+        "size_in_bytes": 2430
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Nicosia",
+        "path_type": "hardlink",
+        "sha256": "fc93b7516933edfdc211ac0822ee88bf7acad1c58a0643b15294f82eb0f14414",
+        "sha256_in_prefix": "fc93b7516933edfdc211ac0822ee88bf7acad1c58a0643b15294f82eb0f14414",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Oslo",
+        "path_type": "hardlink",
+        "sha256": "5a28b5cec79b57d4856e3f05615245e6f74df6388b48bf3f605b792ca3bd972d",
+        "sha256_in_prefix": "5a28b5cec79b57d4856e3f05615245e6f74df6388b48bf3f605b792ca3bd972d",
+        "size_in_bytes": 7922
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Paris",
+        "path_type": "hardlink",
+        "sha256": "ae61491c4a587f56426a9f2118e31060276f2b0231e750c461781577551ca196",
+        "sha256_in_prefix": "ae61491c4a587f56426a9f2118e31060276f2b0231e750c461781577551ca196",
+        "size_in_bytes": 9152
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Podgorica",
+        "path_type": "hardlink",
+        "sha256": "b87630ff459de07eb16cd0c2452660772e3ffc4eeb8419ea77a013b6f63a5900",
+        "sha256_in_prefix": "b87630ff459de07eb16cd0c2452660772e3ffc4eeb8419ea77a013b6f63a5900",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Prague",
+        "path_type": "hardlink",
+        "sha256": "5d3afed5c1b07c6c6635d6bdeb28a0fb4d11a61f25f26c91227b2254be5f4aa0",
+        "sha256_in_prefix": "5d3afed5c1b07c6c6635d6bdeb28a0fb4d11a61f25f26c91227b2254be5f4aa0",
+        "size_in_bytes": 8038
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Riga",
+        "path_type": "hardlink",
+        "sha256": "8b64a42bafd90f9255cacfdbac603d638dd7c18dc27249f9c9b515e1da634424",
+        "sha256_in_prefix": "8b64a42bafd90f9255cacfdbac603d638dd7c18dc27249f9c9b515e1da634424",
+        "size_in_bytes": 7658
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Rome",
+        "path_type": "hardlink",
+        "sha256": "dcd2d9144507311e573568598e1ffd0e0574fb677aa0dafc5641d80a19eb6e58",
+        "sha256_in_prefix": "dcd2d9144507311e573568598e1ffd0e0574fb677aa0dafc5641d80a19eb6e58",
+        "size_in_bytes": 8813
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Samara",
+        "path_type": "hardlink",
+        "sha256": "8f395352aa05d35e7d13380e73659a0d5b56ffc17e3f4e40e4f678a902f0e49b",
+        "sha256_in_prefix": "8f395352aa05d35e7d13380e73659a0d5b56ffc17e3f4e40e4f678a902f0e49b",
+        "size_in_bytes": 2118
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/San_Marino",
+        "path_type": "hardlink",
+        "sha256": "b6856a0e38c2404f7d5fa1821559503f8ae70923a562f0d993124d131515f395",
+        "sha256_in_prefix": "b6856a0e38c2404f7d5fa1821559503f8ae70923a562f0d993124d131515f395",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Sarajevo",
+        "path_type": "hardlink",
+        "sha256": "bc00d953c2f3e55e40eda13838ab66b9e9d0bdad620e4eb917637761abb06fb1",
+        "sha256_in_prefix": "bc00d953c2f3e55e40eda13838ab66b9e9d0bdad620e4eb917637761abb06fb1",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Saratov",
+        "path_type": "hardlink",
+        "sha256": "ab90363dee5077c39ec55fe8e519593ff08223e5a8e593f6cce01fb5b8b35bae",
+        "sha256_in_prefix": "ab90363dee5077c39ec55fe8e519593ff08223e5a8e593f6cce01fb5b8b35bae",
+        "size_in_bytes": 2061
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Simferopol",
+        "path_type": "hardlink",
+        "sha256": "4186a873a6218ff746957a0aaed1d61fc28ff5ed6d44bf38f36b5120a21c06c6",
+        "sha256_in_prefix": "4186a873a6218ff746957a0aaed1d61fc28ff5ed6d44bf38f36b5120a21c06c6",
+        "size_in_bytes": 2389
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Skopje",
+        "path_type": "hardlink",
+        "sha256": "52f20858433261b15797b64f0a09cee95d552ef93b5daa7c141bfab6d718c345",
+        "sha256_in_prefix": "52f20858433261b15797b64f0a09cee95d552ef93b5daa7c141bfab6d718c345",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Sofia",
+        "path_type": "hardlink",
+        "sha256": "6415f279cb143ea598cf8272263ac5b502827b10ceeb242b39e6efcc23a2ee12",
+        "sha256_in_prefix": "6415f279cb143ea598cf8272263ac5b502827b10ceeb242b39e6efcc23a2ee12",
+        "size_in_bytes": 7654
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Stockholm",
+        "path_type": "hardlink",
+        "sha256": "12447ce016745fc14584cb5f753e918c23eca5d028ca50042e0714cf3783608a",
+        "sha256_in_prefix": "12447ce016745fc14584cb5f753e918c23eca5d028ca50042e0714cf3783608a",
+        "size_in_bytes": 7308
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Tallinn",
+        "path_type": "hardlink",
+        "sha256": "6f3594ccda78b02b2ee14c8fae29e668e47193af2dfcf5af1ecd210f13bce9ce",
+        "sha256_in_prefix": "6f3594ccda78b02b2ee14c8fae29e668e47193af2dfcf5af1ecd210f13bce9ce",
+        "size_in_bytes": 7549
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Tirane",
+        "path_type": "hardlink",
+        "sha256": "c62686bf598138fefb72e8cc6632ba75a5fe147f2a30124ee3583be1f732e38d",
+        "sha256_in_prefix": "c62686bf598138fefb72e8cc6632ba75a5fe147f2a30124ee3583be1f732e38d",
+        "size_in_bytes": 7675
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Tiraspol",
+        "path_type": "hardlink",
+        "sha256": "fdd53fdb5f754bbba8ff98f0b1555fe0baeb7852843220a7cf93a190b641a9ad",
+        "sha256_in_prefix": "fdd53fdb5f754bbba8ff98f0b1555fe0baeb7852843220a7cf93a190b641a9ad",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Ulyanovsk",
+        "path_type": "hardlink",
+        "sha256": "9fa9d09509b4f8f5a9c8e422dba02605070c3ebdaeb7c1df8527c8eef5e3632d",
+        "sha256_in_prefix": "9fa9d09509b4f8f5a9c8e422dba02605070c3ebdaeb7c1df8527c8eef5e3632d",
+        "size_in_bytes": 2119
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Uzhgorod",
+        "path_type": "hardlink",
+        "sha256": "747f543b7a875214f8eebfdae3182d91b1e93ceb57b58d2b7657672f949b13a9",
+        "sha256_in_prefix": "747f543b7a875214f8eebfdae3182d91b1e93ceb57b58d2b7657672f949b13a9",
+        "size_in_bytes": 7541
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Vaduz",
+        "path_type": "hardlink",
+        "sha256": "06b235bf047fc2303102bc3dc609a5754a6103321d28440b74eec1c9e3d24642",
+        "sha256_in_prefix": "06b235bf047fc2303102bc3dc609a5754a6103321d28440b74eec1c9e3d24642",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Vatican",
+        "path_type": "hardlink",
+        "sha256": "c203e94465bd1d91018fc7670437226ef9a4bb41d59dde49095363865ca33d00",
+        "sha256_in_prefix": "c203e94465bd1d91018fc7670437226ef9a4bb41d59dde49095363865ca33d00",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Vienna",
+        "path_type": "hardlink",
+        "sha256": "a8165313c9b51daef130401439cba60daa9887fc5eaa61a5afd4f7bad1ad934f",
+        "sha256_in_prefix": "a8165313c9b51daef130401439cba60daa9887fc5eaa61a5afd4f7bad1ad934f",
+        "size_in_bytes": 7930
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Vilnius",
+        "path_type": "hardlink",
+        "sha256": "b762db4a068dc79fa57691e070d7026086e5a6d2fc273d5c1872e7c8e3711533",
+        "sha256_in_prefix": "b762db4a068dc79fa57691e070d7026086e5a6d2fc273d5c1872e7c8e3711533",
+        "size_in_bytes": 7485
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Volgograd",
+        "path_type": "hardlink",
+        "sha256": "22968d40dac2b669e6d2bc43ed6b16c8a9ca3e1f9dacbf8b246299c3c24cc397",
+        "sha256_in_prefix": "22968d40dac2b669e6d2bc43ed6b16c8a9ca3e1f9dacbf8b246299c3c24cc397",
+        "size_in_bytes": 2123
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Warsaw",
+        "path_type": "hardlink",
+        "sha256": "f9dc10ec2ae2cc810a6c08837059b34be651900ba4e1cedb93c209972ccfb5a2",
+        "sha256_in_prefix": "f9dc10ec2ae2cc810a6c08837059b34be651900ba4e1cedb93c209972ccfb5a2",
+        "size_in_bytes": 8662
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Zagreb",
+        "path_type": "hardlink",
+        "sha256": "a49b3894eb84f003eb357647d6a40ceaf6213523196cc1ec24eefd7d9d6d3c3e",
+        "sha256_in_prefix": "a49b3894eb84f003eb357647d6a40ceaf6213523196cc1ec24eefd7d9d6d3c3e",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Zaporozhye",
+        "path_type": "hardlink",
+        "sha256": "f0045f64f64a2c40088f2960616ab8e0aabb8d6309f489fee842056fb8412f72",
+        "sha256_in_prefix": "f0045f64f64a2c40088f2960616ab8e0aabb8d6309f489fee842056fb8412f72",
+        "size_in_bytes": 7490
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Europe/Zurich",
+        "path_type": "hardlink",
+        "sha256": "95afa61e439ca38551306d8fdb11c2788d935c42768d0407c9e4337f105a3e93",
+        "sha256_in_prefix": "95afa61e439ca38551306d8fdb11c2788d935c42768d0407c9e4337f105a3e93",
+        "size_in_bytes": 7305
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/GB",
+        "path_type": "hardlink",
+        "sha256": "e20d829c605a7c5b2a96b83c3480df28c964a13381a8bd2c72c2a37295131fa7",
+        "sha256_in_prefix": "e20d829c605a7c5b2a96b83c3480df28c964a13381a8bd2c72c2a37295131fa7",
+        "size_in_bytes": 170
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/GB-Eire",
+        "path_type": "hardlink",
+        "sha256": "c9334480d0a970254b6ba6ff22e958dc8dd8bf06288229461a551c7c094c3f1d",
+        "sha256_in_prefix": "c9334480d0a970254b6ba6ff22e958dc8dd8bf06288229461a551c7c094c3f1d",
+        "size_in_bytes": 175
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/GMT",
+        "path_type": "hardlink",
+        "sha256": "747c15cdc239855d5380b7a7f47112f2a26c61b0bf300eeb9711e6521550d189",
+        "sha256_in_prefix": "747c15cdc239855d5380b7a7f47112f2a26c61b0bf300eeb9711e6521550d189",
+        "size_in_bytes": 153
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/GMT+0",
+        "path_type": "hardlink",
+        "sha256": "be48462ccfbb3aee19597f082a17c2c5d2fd8bb1c9122245efab0a51f8f413b0",
+        "sha256_in_prefix": "be48462ccfbb3aee19597f082a17c2c5d2fd8bb1c9122245efab0a51f8f413b0",
+        "size_in_bytes": 155
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/GMT-0",
+        "path_type": "hardlink",
+        "sha256": "944c86f516141ddc3aec1ae4a963e9769879c48ed12daddf4ed63a01313acd00",
+        "sha256_in_prefix": "944c86f516141ddc3aec1ae4a963e9769879c48ed12daddf4ed63a01313acd00",
+        "size_in_bytes": 155
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/GMT0",
+        "path_type": "hardlink",
+        "sha256": "54850a5f488205db01fbb46e2da9fff951c4571029ea64d35932ddea5346daaf",
+        "sha256_in_prefix": "54850a5f488205db01fbb46e2da9fff951c4571029ea64d35932ddea5346daaf",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Greenwich",
+        "path_type": "hardlink",
+        "sha256": "9e7a8daa26ce36e8f7d7f13460915c063ee98e2a4db276ad9d15ca5c7c06815f",
+        "sha256_in_prefix": "9e7a8daa26ce36e8f7d7f13460915c063ee98e2a4db276ad9d15ca5c7c06815f",
+        "size_in_bytes": 159
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/HST",
+        "path_type": "hardlink",
+        "sha256": "8d710699af319e0ddb83e9f3a32d07ae8082ea2f7eabbd345effffb0f563062e",
+        "sha256_in_prefix": "8d710699af319e0ddb83e9f3a32d07ae8082ea2f7eabbd345effffb0f563062e",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Hongkong",
+        "path_type": "hardlink",
+        "sha256": "359c9c02a9fa3de10ba48fa0ab47d8d7aff3b47f950cfaf5eb68f842ea52ab21",
+        "sha256_in_prefix": "359c9c02a9fa3de10ba48fa0ab47d8d7aff3b47f950cfaf5eb68f842ea52ab21",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Iceland",
+        "path_type": "hardlink",
+        "sha256": "e4ab3a08ed590d907f9741d4b8fe27e552b19fe0257f14ce2ed5289d5685974c",
+        "sha256_in_prefix": "e4ab3a08ed590d907f9741d4b8fe27e552b19fe0257f14ce2ed5289d5685974c",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Antananarivo",
+        "path_type": "hardlink",
+        "sha256": "1b1177ce4d59d7cbcae9b0421eb00ad341ecb299bd15773d4ed077f0f2ce7b38",
+        "sha256_in_prefix": "1b1177ce4d59d7cbcae9b0421eb00ad341ecb299bd15773d4ed077f0f2ce7b38",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Chagos",
+        "path_type": "hardlink",
+        "sha256": "11044ad7cb0848cc734d2a67128aa6ac07cb89268399aa0a71a99024de4b8879",
+        "sha256_in_prefix": "11044ad7cb0848cc734d2a67128aa6ac07cb89268399aa0a71a99024de4b8879",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Christmas",
+        "path_type": "hardlink",
+        "sha256": "cb43deafad0f8bf7de8567841790a58d358ef2b210bb2022686b3eb7f97b2e5b",
+        "sha256_in_prefix": "cb43deafad0f8bf7de8567841790a58d358ef2b210bb2022686b3eb7f97b2e5b",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Cocos",
+        "path_type": "hardlink",
+        "sha256": "71194b896cc00967ebbe3f9f4609f8c5cd73ce56b2529646a7a6ac679bb03400",
+        "sha256_in_prefix": "71194b896cc00967ebbe3f9f4609f8c5cd73ce56b2529646a7a6ac679bb03400",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Comoro",
+        "path_type": "hardlink",
+        "sha256": "53fa58e32dc2e4abb574b2f78011815eeb7f89f453cc63c6b6c1460abbb4ca5c",
+        "sha256_in_prefix": "53fa58e32dc2e4abb574b2f78011815eeb7f89f453cc63c6b6c1460abbb4ca5c",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Kerguelen",
+        "path_type": "hardlink",
+        "sha256": "c7afde6978d8ce5413730d370e2776e2acc7d96570a6034eb504c0f42ca5d1e7",
+        "sha256_in_prefix": "c7afde6978d8ce5413730d370e2776e2acc7d96570a6034eb504c0f42ca5d1e7",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Mahe",
+        "path_type": "hardlink",
+        "sha256": "8e1d0f7268a5ee75e8a7c17fd6e1a9880bad18a612346c29d70b462024d7371e",
+        "sha256_in_prefix": "8e1d0f7268a5ee75e8a7c17fd6e1a9880bad18a612346c29d70b462024d7371e",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Maldives",
+        "path_type": "hardlink",
+        "sha256": "9fac69dc609cc6074ecd67e0be8ae62e33d8d9c7f055a3e0dee1430c7ffc54f6",
+        "sha256_in_prefix": "9fac69dc609cc6074ecd67e0be8ae62e33d8d9c7f055a3e0dee1430c7ffc54f6",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Mauritius",
+        "path_type": "hardlink",
+        "sha256": "a2b1b93cbeecbd900ed71e61a4932509eb52688e97a6015dad067066d0d42072",
+        "sha256_in_prefix": "a2b1b93cbeecbd900ed71e61a4932509eb52688e97a6015dad067066d0d42072",
+        "size_in_bytes": 272
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Mayotte",
+        "path_type": "hardlink",
+        "sha256": "845c45fd7b6f0604b03a3c72db117878b568fb537bca078304727964157b96ab",
+        "sha256_in_prefix": "845c45fd7b6f0604b03a3c72db117878b568fb537bca078304727964157b96ab",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Indian/Reunion",
+        "path_type": "hardlink",
+        "sha256": "e039b16caab8f5d8f85625e0cc1d0fe42369715f2a4810bdf7f9cf19a28b5603",
+        "sha256_in_prefix": "e039b16caab8f5d8f85625e0cc1d0fe42369715f2a4810bdf7f9cf19a28b5603",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Iran",
+        "path_type": "hardlink",
+        "sha256": "fe7f4453cb5f6b81b23c1c795356b91fe319f0762be7868fafe361db1f9c2a2b",
+        "sha256_in_prefix": "fe7f4453cb5f6b81b23c1c795356b91fe319f0762be7868fafe361db1f9c2a2b",
+        "size_in_bytes": 166
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Israel",
+        "path_type": "hardlink",
+        "sha256": "805105f5f17b78929f8476bae83ed972128633ff6f74b7748b063e3c810c27a6",
+        "sha256_in_prefix": "805105f5f17b78929f8476bae83ed972128633ff6f74b7748b063e3c810c27a6",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Jamaica",
+        "path_type": "hardlink",
+        "sha256": "f01b00d52bd7b2694bf5cb55a17028c30a41bd22a774ca54740e8b1dde4fcb2e",
+        "sha256_in_prefix": "f01b00d52bd7b2694bf5cb55a17028c30a41bd22a774ca54740e8b1dde4fcb2e",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Japan",
+        "path_type": "hardlink",
+        "sha256": "98dbd07ae3b9251b9091f4d265336ce98bdfb492af863c1f3ff25248a2cadf35",
+        "sha256_in_prefix": "98dbd07ae3b9251b9091f4d265336ce98bdfb492af863c1f3ff25248a2cadf35",
+        "size_in_bytes": 164
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Kwajalein",
+        "path_type": "hardlink",
+        "sha256": "85e95363acf468043cd5146927a97b2d9e3b141eda0a7993dada9382d1d6dd54",
+        "sha256_in_prefix": "85e95363acf468043cd5146927a97b2d9e3b141eda0a7993dada9382d1d6dd54",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Libya",
+        "path_type": "hardlink",
+        "sha256": "f776839c1999056e6a0d2ecfdf9054fc309454afdff8e8bc803f33ec423b7361",
+        "sha256_in_prefix": "f776839c1999056e6a0d2ecfdf9054fc309454afdff8e8bc803f33ec423b7361",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/MET",
+        "path_type": "hardlink",
+        "sha256": "df45f5414f1636b1856c7534bb5f3d4387c32d56283a68bb47d8c48c1ddad5bc",
+        "sha256_in_prefix": "df45f5414f1636b1856c7534bb5f3d4387c32d56283a68bb47d8c48c1ddad5bc",
+        "size_in_bytes": 7736
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/MST",
+        "path_type": "hardlink",
+        "sha256": "e57746d5db479a8b30973f2bc16e2b8dfb6e2bfaecbff0fb956f04526e4b935b",
+        "sha256_in_prefix": "e57746d5db479a8b30973f2bc16e2b8dfb6e2bfaecbff0fb956f04526e4b935b",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/MST7MDT",
+        "path_type": "hardlink",
+        "sha256": "a5deb89d59613d9a54c1e146056a805b3de9f2a2593aec2b8a25f863328699c0",
+        "sha256_in_prefix": "a5deb89d59613d9a54c1e146056a805b3de9f2a2593aec2b8a25f863328699c0",
+        "size_in_bytes": 8505
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Mexico/BajaNorte",
+        "path_type": "hardlink",
+        "sha256": "f8ca38a845cd01bf785ee222277dad9325ab6bd17e44a362c450855aeb522814",
+        "sha256_in_prefix": "f8ca38a845cd01bf785ee222277dad9325ab6bd17e44a362c450855aeb522814",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Mexico/BajaSur",
+        "path_type": "hardlink",
+        "sha256": "2e6e32a40487f0146b59150b66ff74901ca853b12d47922819af23eea5b4149c",
+        "sha256_in_prefix": "2e6e32a40487f0146b59150b66ff74901ca853b12d47922819af23eea5b4149c",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Mexico/General",
+        "path_type": "hardlink",
+        "sha256": "2dff1b83fecfad5c27ec47b206696c29b91398f8185b5d406a66fa9e0aeca93f",
+        "sha256_in_prefix": "2dff1b83fecfad5c27ec47b206696c29b91398f8185b5d406a66fa9e0aeca93f",
+        "size_in_bytes": 200
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/NZ",
+        "path_type": "hardlink",
+        "sha256": "e22d629d53c54960ad156c377de0ae461c27f554990a3d1305724ca8f869bce4",
+        "sha256_in_prefix": "e22d629d53c54960ad156c377de0ae461c27f554990a3d1305724ca8f869bce4",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/NZ-CHAT",
+        "path_type": "hardlink",
+        "sha256": "83f4ca3522b64f9b151edefae53e0f28c2e6c4ce16d0982186b3344f2a268724",
+        "sha256_in_prefix": "83f4ca3522b64f9b151edefae53e0f28c2e6c4ce16d0982186b3344f2a268724",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Navajo",
+        "path_type": "hardlink",
+        "sha256": "2cc8ce235f2ee3160e6afd04a4e28aa0312494ebb6fed08d8cc81d414ec540ee",
+        "sha256_in_prefix": "2cc8ce235f2ee3160e6afd04a4e28aa0312494ebb6fed08d8cc81d414ec540ee",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/PRC",
+        "path_type": "hardlink",
+        "sha256": "6a5baa9ca54b2a2c6d21287443be0b1064aa79b5c4c62939933f8a0ad842b73e",
+        "sha256_in_prefix": "6a5baa9ca54b2a2c6d21287443be0b1064aa79b5c4c62939933f8a0ad842b73e",
+        "size_in_bytes": 171
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/PST8PDT",
+        "path_type": "hardlink",
+        "sha256": "d148708f1e70eefa51e88e5823776cbe710535d4d6d6356e7753a44463a1c5ab",
+        "sha256_in_prefix": "d148708f1e70eefa51e88e5823776cbe710535d4d6d6356e7753a44463a1c5ab",
+        "size_in_bytes": 8505
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Apia",
+        "path_type": "hardlink",
+        "sha256": "983884249acc11c3fe740d78e72b1a89be9c8b077283549bf6bcd8c93fa71731",
+        "sha256_in_prefix": "983884249acc11c3fe740d78e72b1a89be9c8b077283549bf6bcd8c93fa71731",
+        "size_in_bytes": 909
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Auckland",
+        "path_type": "hardlink",
+        "sha256": "201cfadb00fbcd3283249dad73872ed75c5bec07f5a5b157726638c20728b833",
+        "sha256_in_prefix": "201cfadb00fbcd3283249dad73872ed75c5bec07f5a5b157726638c20728b833",
+        "size_in_bytes": 8772
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Bougainville",
+        "path_type": "hardlink",
+        "sha256": "2d3bfded297214ba25cfd8c6f508d0c8b1a1cd7d46701a78ec5e510076185eb6",
+        "sha256_in_prefix": "2d3bfded297214ba25cfd8c6f508d0c8b1a1cd7d46701a78ec5e510076185eb6",
+        "size_in_bytes": 280
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Chatham",
+        "path_type": "hardlink",
+        "sha256": "ca0eef84dbc5964ef2265e9252237be58bb8d75c34817cc2305cccfaec7e690c",
+        "sha256_in_prefix": "ca0eef84dbc5964ef2265e9252237be58bb8d75c34817cc2305cccfaec7e690c",
+        "size_in_bytes": 8165
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Chuuk",
+        "path_type": "hardlink",
+        "sha256": "492df366bb0a7d29d2db4a9c40cf0c15cb47343ff908d1aa86092c8e84e4434b",
+        "sha256_in_prefix": "492df366bb0a7d29d2db4a9c40cf0c15cb47343ff908d1aa86092c8e84e4434b",
+        "size_in_bytes": 305
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Easter",
+        "path_type": "hardlink",
+        "sha256": "84b815988d1a5ac16f3ec52844bdce7a8e8707800c782235b5928473eef9b433",
+        "sha256_in_prefix": "84b815988d1a5ac16f3ec52844bdce7a8e8707800c782235b5928473eef9b433",
+        "size_in_bytes": 8203
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Efate",
+        "path_type": "hardlink",
+        "sha256": "332372e5efb46123fbb66f9f32f91b59ebd88adb956249db3f14caab01ce2655",
+        "sha256_in_prefix": "332372e5efb46123fbb66f9f32f91b59ebd88adb956249db3f14caab01ce2655",
+        "size_in_bytes": 789
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Enderbury",
+        "path_type": "hardlink",
+        "sha256": "790e6b48b261d6def7d183cc8f38fb8d8a6e3efb8844281efabb2dfd621e53b5",
+        "sha256_in_prefix": "790e6b48b261d6def7d183cc8f38fb8d8a6e3efb8844281efabb2dfd621e53b5",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Fakaofo",
+        "path_type": "hardlink",
+        "sha256": "336058dca4802c79ed43f6177adb73085d4fa0754b94051cae2a19346b0c4904",
+        "sha256_in_prefix": "336058dca4802c79ed43f6177adb73085d4fa0754b94051cae2a19346b0c4904",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Fiji",
+        "path_type": "hardlink",
+        "sha256": "a29faaee67bc07f5df858dac070f03e45e29b67a5f9de6dd992e79a9601979b7",
+        "sha256_in_prefix": "a29faaee67bc07f5df858dac070f03e45e29b67a5f9de6dd992e79a9601979b7",
+        "size_in_bytes": 5636
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Funafuti",
+        "path_type": "hardlink",
+        "sha256": "b2acf1461318a0b21653b6f21de5e54651a417a469aad0dbf8099626040beb51",
+        "sha256_in_prefix": "b2acf1461318a0b21653b6f21de5e54651a417a469aad0dbf8099626040beb51",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Galapagos",
+        "path_type": "hardlink",
+        "sha256": "192545659f971084adc8489a2b96a6439ff391599dc962aa13375accfb3c09d9",
+        "sha256_in_prefix": "192545659f971084adc8489a2b96a6439ff391599dc962aa13375accfb3c09d9",
+        "size_in_bytes": 247
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Gambier",
+        "path_type": "hardlink",
+        "sha256": "190e02a0c00d165fa45c73aef9c0d6c82b1720e7406e5610dd860aed10a021a5",
+        "sha256_in_prefix": "190e02a0c00d165fa45c73aef9c0d6c82b1720e7406e5610dd860aed10a021a5",
+        "size_in_bytes": 155
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Guadalcanal",
+        "path_type": "hardlink",
+        "sha256": "161762334dff48b1d58824911e1ff4171386ea18234dd3dd5b0798515593086a",
+        "sha256_in_prefix": "161762334dff48b1d58824911e1ff4171386ea18234dd3dd5b0798515593086a",
+        "size_in_bytes": 157
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Guam",
+        "path_type": "hardlink",
+        "sha256": "42cb69abc83415f63ca7d2a3e5314a41817aee3206eccc7172c50a74b1597db0",
+        "sha256_in_prefix": "42cb69abc83415f63ca7d2a3e5314a41817aee3206eccc7172c50a74b1597db0",
+        "size_in_bytes": 733
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Honolulu",
+        "path_type": "hardlink",
+        "sha256": "69319015799d32d3cf7c0a3e9991b4b1f3e0c5d1b4fbf400517350cca9d2c3b7",
+        "sha256_in_prefix": "69319015799d32d3cf7c0a3e9991b4b1f3e0c5d1b4fbf400517350cca9d2c3b7",
+        "size_in_bytes": 344
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Johnston",
+        "path_type": "hardlink",
+        "sha256": "6e52b361ac8a6a578c709f6d58aa7535f06c0cb1707081c2d5a63fa8545d955c",
+        "sha256_in_prefix": "6e52b361ac8a6a578c709f6d58aa7535f06c0cb1707081c2d5a63fa8545d955c",
+        "size_in_bytes": 193
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Kanton",
+        "path_type": "hardlink",
+        "sha256": "0b1345555ec2b4738cc4debfe496c287966f238386263032ff1e27912ccbfba6",
+        "sha256_in_prefix": "0b1345555ec2b4738cc4debfe496c287966f238386263032ff1e27912ccbfba6",
+        "size_in_bytes": 208
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Kiritimati",
+        "path_type": "hardlink",
+        "sha256": "4f7235b956a5a01676be05275e086d5157ebc24fd91022e87817020669f915f7",
+        "sha256_in_prefix": "4f7235b956a5a01676be05275e086d5157ebc24fd91022e87817020669f915f7",
+        "size_in_bytes": 219
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Kosrae",
+        "path_type": "hardlink",
+        "sha256": "b528e5e712e5f878603183e7ccff55e5db97cb47d7628bcb635342796317b899",
+        "sha256_in_prefix": "b528e5e712e5f878603183e7ccff55e5db97cb47d7628bcb635342796317b899",
+        "size_in_bytes": 394
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Kwajalein",
+        "path_type": "hardlink",
+        "sha256": "38133be70100d7dc244a680827879e6b240646c7c0b68f58652051e681a71985",
+        "sha256_in_prefix": "38133be70100d7dc244a680827879e6b240646c7c0b68f58652051e681a71985",
+        "size_in_bytes": 304
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Majuro",
+        "path_type": "hardlink",
+        "sha256": "67ea1a2a84e0fa686c04ef327e7eeaccc15e21bed79a801e64bb57fe4184509a",
+        "sha256_in_prefix": "67ea1a2a84e0fa686c04ef327e7eeaccc15e21bed79a801e64bb57fe4184509a",
+        "size_in_bytes": 333
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Marquesas",
+        "path_type": "hardlink",
+        "sha256": "ae0b5055c6e57516f23749b13681205ead376e682959716a457b1377af8160ba",
+        "sha256_in_prefix": "ae0b5055c6e57516f23749b13681205ead376e682959716a457b1377af8160ba",
+        "size_in_bytes": 159
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Midway",
+        "path_type": "hardlink",
+        "sha256": "f62c6a2dec1e9ec78115d5f14e5b9db7c86f788662d2e68f7e6714f4a05dc974",
+        "sha256_in_prefix": "f62c6a2dec1e9ec78115d5f14e5b9db7c86f788662d2e68f7e6714f4a05dc974",
+        "size_in_bytes": 194
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Nauru",
+        "path_type": "hardlink",
+        "sha256": "22c367f3219b5fc736260d9dbfef5fcb767f1a6bda991c9352f790a3d1ffe884",
+        "sha256_in_prefix": "22c367f3219b5fc736260d9dbfef5fcb767f1a6bda991c9352f790a3d1ffe884",
+        "size_in_bytes": 244
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Niue",
+        "path_type": "hardlink",
+        "sha256": "869cca656be88e4e7481c75737c3656bab6924ad1751505815ac719c59269842",
+        "sha256_in_prefix": "869cca656be88e4e7481c75737c3656bab6924ad1751505815ac719c59269842",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Norfolk",
+        "path_type": "hardlink",
+        "sha256": "5d16c3ef1db996c1b8e33ad884c33946f77da872f35f41ec3bd5b288f43cc9af",
+        "sha256_in_prefix": "5d16c3ef1db996c1b8e33ad884c33946f77da872f35f41ec3bd5b288f43cc9af",
+        "size_in_bytes": 5139
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Noumea",
+        "path_type": "hardlink",
+        "sha256": "238683c027d2319c33d975a837e9fc9d24dd53b1a67108edbf7abdf0db050881",
+        "sha256_in_prefix": "238683c027d2319c33d975a837e9fc9d24dd53b1a67108edbf7abdf0db050881",
+        "size_in_bytes": 326
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Pago_Pago",
+        "path_type": "hardlink",
+        "sha256": "cca96640ab3bc707224fa86d9af66f9d53a204a97b370b2785ba8208688bf8b6",
+        "sha256_in_prefix": "cca96640ab3bc707224fa86d9af66f9d53a204a97b370b2785ba8208688bf8b6",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Palau",
+        "path_type": "hardlink",
+        "sha256": "97de6c2c717bfead00f83b5d39d654c32cee580226f5f084484ebad57bbce7ff",
+        "sha256_in_prefix": "97de6c2c717bfead00f83b5d39d654c32cee580226f5f084484ebad57bbce7ff",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Pitcairn",
+        "path_type": "hardlink",
+        "sha256": "5d363729a986e24c79f4b817cc88d2b22accce3add20138d51c4422c4297ad6f",
+        "sha256_in_prefix": "5d363729a986e24c79f4b817cc88d2b22accce3add20138d51c4422c4297ad6f",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Pohnpei",
+        "path_type": "hardlink",
+        "sha256": "88d62b644bb96a9318427b4ca56db37c8217da449328c801ed77007be9420f9c",
+        "sha256_in_prefix": "88d62b644bb96a9318427b4ca56db37c8217da449328c801ed77007be9420f9c",
+        "size_in_bytes": 338
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Ponape",
+        "path_type": "hardlink",
+        "sha256": "edc43ef78691a1b22d111bc4390ea442b893e61771a6fd76bdae1d46c5904c0c",
+        "sha256_in_prefix": "edc43ef78691a1b22d111bc4390ea442b893e61771a6fd76bdae1d46c5904c0c",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Port_Moresby",
+        "path_type": "hardlink",
+        "sha256": "124c137b091d9d54d5e0579131485428faae040acc978d20d6a8c8e4de9889aa",
+        "sha256_in_prefix": "124c137b091d9d54d5e0579131485428faae040acc978d20d6a8c8e4de9889aa",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Rarotonga",
+        "path_type": "hardlink",
+        "sha256": "5ab006a686e564e30c94884ff8a9d728aec74681da8772e9722b6fe203630b5d",
+        "sha256_in_prefix": "5ab006a686e564e30c94884ff8a9d728aec74681da8772e9722b6fe203630b5d",
+        "size_in_bytes": 969
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Saipan",
+        "path_type": "hardlink",
+        "sha256": "4f6a1c20a11e186012466091cd4b3c09d89d35e7560f93874dec2d7f99365589",
+        "sha256_in_prefix": "4f6a1c20a11e186012466091cd4b3c09d89d35e7560f93874dec2d7f99365589",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Samoa",
+        "path_type": "hardlink",
+        "sha256": "98d06302efc18fad7751f7e5a059fe4abafbc361fdc365fe1eb576209d92c658",
+        "sha256_in_prefix": "98d06302efc18fad7751f7e5a059fe4abafbc361fdc365fe1eb576209d92c658",
+        "size_in_bytes": 193
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Tahiti",
+        "path_type": "hardlink",
+        "sha256": "440a87ddb4f304dcbeaed1b0de8f6058840e597918b688e0782f584da03b1bbc",
+        "sha256_in_prefix": "440a87ddb4f304dcbeaed1b0de8f6058840e597918b688e0782f584da03b1bbc",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Tarawa",
+        "path_type": "hardlink",
+        "sha256": "91aa5da8d5d1e72b1f561d0aeab4b07e02edd4eb95ae8c9f1c503c820460599f",
+        "sha256_in_prefix": "91aa5da8d5d1e72b1f561d0aeab4b07e02edd4eb95ae8c9f1c503c820460599f",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Tongatapu",
+        "path_type": "hardlink",
+        "sha256": "ecc9d2e7ad7b5e5d6599cf442941595c99c4d69e802a4ddb4da321898cdde91d",
+        "sha256_in_prefix": "ecc9d2e7ad7b5e5d6599cf442941595c99c4d69e802a4ddb4da321898cdde91d",
+        "size_in_bytes": 451
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Truk",
+        "path_type": "hardlink",
+        "sha256": "bdd8c779af9d671ad7f20832fff8eb3b25c9989a619c23337743f112ff4c8764",
+        "sha256_in_prefix": "bdd8c779af9d671ad7f20832fff8eb3b25c9989a619c23337743f112ff4c8764",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Wake",
+        "path_type": "hardlink",
+        "sha256": "2d18d9ab10c9d8947a88d486d0bc0b0523049a2ed2ca2fbdfa0577e40f189d13",
+        "sha256_in_prefix": "2d18d9ab10c9d8947a88d486d0bc0b0523049a2ed2ca2fbdfa0577e40f189d13",
+        "size_in_bytes": 150
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Wallis",
+        "path_type": "hardlink",
+        "sha256": "a3d83e6c504eac75c4cd87b696f0df2703d0a78df27d8b1fac161acb07f2a9de",
+        "sha256_in_prefix": "a3d83e6c504eac75c4cd87b696f0df2703d0a78df27d8b1fac161acb07f2a9de",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Pacific/Yap",
+        "path_type": "hardlink",
+        "sha256": "e348a2d02966cf9599b5f6f1f5b6c3412113def548bd322f0c22376106e12d92",
+        "sha256_in_prefix": "e348a2d02966cf9599b5f6f1f5b6c3412113def548bd322f0c22376106e12d92",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Poland",
+        "path_type": "hardlink",
+        "sha256": "c27e1179b55bf0c7db6f1c334c0c20c4afa4dbb84db6f46244b118f7eab9c76e",
+        "sha256_in_prefix": "c27e1179b55bf0c7db6f1c334c0c20c4afa4dbb84db6f46244b118f7eab9c76e",
+        "size_in_bytes": 174
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Portugal",
+        "path_type": "hardlink",
+        "sha256": "efd666f3062d52c5d0b4f83b1a206e6840c1eaec356cd77a0a71c7edfa78c964",
+        "sha256_in_prefix": "efd666f3062d52c5d0b4f83b1a206e6840c1eaec356cd77a0a71c7edfa78c964",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/ROC",
+        "path_type": "hardlink",
+        "sha256": "9aec39777013b23d63d0509ebb2f01d57a2c1592264dbb19ce2c61c7d7ddd8de",
+        "sha256_in_prefix": "9aec39777013b23d63d0509ebb2f01d57a2c1592264dbb19ce2c61c7d7ddd8de",
+        "size_in_bytes": 165
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/ROK",
+        "path_type": "hardlink",
+        "sha256": "63153b40225270adb7cd248788ca9f18c6debaf222b3165bbab633337592df44",
+        "sha256_in_prefix": "63153b40225270adb7cd248788ca9f18c6debaf222b3165bbab633337592df44",
+        "size_in_bytes": 162
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Singapore",
+        "path_type": "hardlink",
+        "sha256": "b9443fb17f0128ddb9f2df657dc5d2df176f64c61b0d02b272e5dfb108537678",
+        "sha256_in_prefix": "b9443fb17f0128ddb9f2df657dc5d2df176f64c61b0d02b272e5dfb108537678",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/AST4",
+        "path_type": "hardlink",
+        "sha256": "978c4e5256057ce7374ad7929605090fc749b55558495bd0112fb0bb743fa9c2",
+        "sha256_in_prefix": "978c4e5256057ce7374ad7929605090fc749b55558495bd0112fb0bb743fa9c2",
+        "size_in_bytes": 201
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/AST4ADT",
+        "path_type": "hardlink",
+        "sha256": "0114c111f5bcd838a28f2e16e01ecb79d8afc8cbf639a672889ed0d692fc6cdc",
+        "sha256_in_prefix": "0114c111f5bcd838a28f2e16e01ecb79d8afc8cbf639a672889ed0d692fc6cdc",
+        "size_in_bytes": 192
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/CST6",
+        "path_type": "hardlink",
+        "sha256": "30428b85b37898ad98b65be5b6a8bd599331d9a1b49605fc6521464228e32f8f",
+        "sha256_in_prefix": "30428b85b37898ad98b65be5b6a8bd599331d9a1b49605fc6521464228e32f8f",
+        "size_in_bytes": 186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/CST6CDT",
+        "path_type": "hardlink",
+        "sha256": "44bef7d4660a9a873eb762e3fdc651d31d97893545de643fa1b2d05991c090a1",
+        "sha256_in_prefix": "44bef7d4660a9a873eb762e3fdc651d31d97893545de643fa1b2d05991c090a1",
+        "size_in_bytes": 192
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/EST5",
+        "path_type": "hardlink",
+        "sha256": "798f92e5dda65818c887750016d19e6ee9445adfe0fcb7acb11281293a09c2c7",
+        "sha256_in_prefix": "798f92e5dda65818c887750016d19e6ee9445adfe0fcb7acb11281293a09c2c7",
+        "size_in_bytes": 204
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/EST5EDT",
+        "path_type": "hardlink",
+        "sha256": "d159140114a13c69f073cfe9ad0b67d713e8811cbff773a3d1681fc38ea0e699",
+        "sha256_in_prefix": "d159140114a13c69f073cfe9ad0b67d713e8811cbff773a3d1681fc38ea0e699",
+        "size_in_bytes": 195
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/HST10",
+        "path_type": "hardlink",
+        "sha256": "bf62c8650bba258000f62f16b0c7cbb66f4fd63f8cfdaf54273bb88a02a6c8d6",
+        "sha256_in_prefix": "bf62c8650bba258000f62f16b0c7cbb66f4fd63f8cfdaf54273bb88a02a6c8d6",
+        "size_in_bytes": 193
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/MST7",
+        "path_type": "hardlink",
+        "sha256": "febe49fae260e5595b6f1b21a0a3458d8a50aca72f4551bf10c1edb2758e0304",
+        "sha256_in_prefix": "febe49fae260e5595b6f1b21a0a3458d8a50aca72f4551bf10c1edb2758e0304",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/MST7MDT",
+        "path_type": "hardlink",
+        "sha256": "64556a7b20e425c79375c2a7ccf72b2b5223a7de4ff4c99a5c039db3456c63f6",
+        "sha256_in_prefix": "64556a7b20e425c79375c2a7ccf72b2b5223a7de4ff4c99a5c039db3456c63f6",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/PST8",
+        "path_type": "hardlink",
+        "sha256": "0b8227afc94082c985e8e125df83e5efade7cd9ca399800d7b8e8b2beae22c7d",
+        "sha256_in_prefix": "0b8227afc94082c985e8e125df83e5efade7cd9ca399800d7b8e8b2beae22c7d",
+        "size_in_bytes": 192
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/PST8PDT",
+        "path_type": "hardlink",
+        "sha256": "d51d9549835e9c058f836c8952932cb53c10f7f194cd87452e9b13494d1c54c9",
+        "sha256_in_prefix": "d51d9549835e9c058f836c8952932cb53c10f7f194cd87452e9b13494d1c54c9",
+        "size_in_bytes": 204
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/YST9",
+        "path_type": "hardlink",
+        "sha256": "55710efded5b5830b2f3a2a072037c5251e1766f318707ed7cd5eb03037fed43",
+        "sha256_in_prefix": "55710efded5b5830b2f3a2a072037c5251e1766f318707ed7cd5eb03037fed43",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/SystemV/YST9YDT",
+        "path_type": "hardlink",
+        "sha256": "da20018de301f879e4f026405c69fa0370eb10184fe1c84a4f1504079d5dafa1",
+        "sha256_in_prefix": "da20018de301f879e4f026405c69fa0370eb10184fe1c84a4f1504079d5dafa1",
+        "size_in_bytes": 198
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Turkey",
+        "path_type": "hardlink",
+        "sha256": "8471a5575b9d9e47412d851a18a26c4405480540aabc8daed5f81be0c714c07c",
+        "sha256_in_prefix": "8471a5575b9d9e47412d851a18a26c4405480540aabc8daed5f81be0c714c07c",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/UCT",
+        "path_type": "hardlink",
+        "sha256": "356a9bb6f831971c295cf4dce0f0cdc9edf94fd686ca3d3195e5f031a0b67cba",
+        "sha256_in_prefix": "356a9bb6f831971c295cf4dce0f0cdc9edf94fd686ca3d3195e5f031a0b67cba",
+        "size_in_bytes": 153
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Alaska",
+        "path_type": "hardlink",
+        "sha256": "ced56f09d68be00555219594c7b2f3e7efe8323201fb3e2aa0e1fa9a6467d5af",
+        "sha256_in_prefix": "ced56f09d68be00555219594c7b2f3e7efe8323201fb3e2aa0e1fa9a6467d5af",
+        "size_in_bytes": 189
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Aleutian",
+        "path_type": "hardlink",
+        "sha256": "a4f1398cf84d0ae09bf19288770756622d1710ccbfbfe79e0d3239497731287d",
+        "sha256_in_prefix": "a4f1398cf84d0ae09bf19288770756622d1710ccbfbfe79e0d3239497731287d",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Arizona",
+        "path_type": "hardlink",
+        "sha256": "9503403f231ba33415a5f2f0fdd3771ce7ff78534ce83c16a8db5bc333b4ad8a",
+        "sha256_in_prefix": "9503403f231ba33415a5f2f0fdd3771ce7ff78534ce83c16a8db5bc333b4ad8a",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Central",
+        "path_type": "hardlink",
+        "sha256": "b6ac9fae0ab69d58ecfd6b9a84f3c6d3e1a594e40ceec94e2a0a7855781e173a",
+        "sha256_in_prefix": "b6ac9fae0ab69d58ecfd6b9a84f3c6d3e1a594e40ceec94e2a0a7855781e173a",
+        "size_in_bytes": 184
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/East-Indiana",
+        "path_type": "hardlink",
+        "sha256": "5d86f8d36598516fb2342a18a87db2701babd265b0671cc9321c48db22c7eca5",
+        "sha256_in_prefix": "5d86f8d36598516fb2342a18a87db2701babd265b0671cc9321c48db22c7eca5",
+        "size_in_bytes": 228
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Eastern",
+        "path_type": "hardlink",
+        "sha256": "2ffcad8cbef5ecdc74db3ee773e4b18abc8efa9c09c4ea8f3a45a08badaf91a9",
+        "sha256_in_prefix": "2ffcad8cbef5ecdc74db3ee773e4b18abc8efa9c09c4ea8f3a45a08badaf91a9",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Hawaii",
+        "path_type": "hardlink",
+        "sha256": "529bb43efda6c1584feaea789b590cef1397e33457ab3845f3101b1fc126e0fb",
+        "sha256_in_prefix": "529bb43efda6c1584feaea789b590cef1397e33457ab3845f3101b1fc126e0fb",
+        "size_in_bytes": 186
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Indiana-Starke",
+        "path_type": "hardlink",
+        "sha256": "5827b6a6d50cf0fb75d6ba6e36282591ad25e1f0be636dcfc5d09bda29a107fd",
+        "sha256_in_prefix": "5827b6a6d50cf0fb75d6ba6e36282591ad25e1f0be636dcfc5d09bda29a107fd",
+        "size_in_bytes": 206
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Michigan",
+        "path_type": "hardlink",
+        "sha256": "b4e4269c4febfeff26750b297a590226c0a6872519a6bfde36f6dc3f6f756349",
+        "sha256_in_prefix": "b4e4269c4febfeff26750b297a590226c0a6872519a6bfde36f6dc3f6f756349",
+        "size_in_bytes": 185
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Mountain",
+        "path_type": "hardlink",
+        "sha256": "3763bf520d3c97148c34dcfbdf70dec2636d4e38241555900c058efee3bd1256",
+        "sha256_in_prefix": "3763bf520d3c97148c34dcfbdf70dec2636d4e38241555900c058efee3bd1256",
+        "size_in_bytes": 182
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Pacific",
+        "path_type": "hardlink",
+        "sha256": "54e5f126d4e7cc13555841a61ff66c0350621c089f475638a393930b3fb4918c",
+        "sha256_in_prefix": "54e5f126d4e7cc13555841a61ff66c0350621c089f475638a393930b3fb4918c",
+        "size_in_bytes": 196
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Pacific-New",
+        "path_type": "hardlink",
+        "sha256": "b14c515d5823e7f6e4c67892fa376d54db748fab139c4d40db50f22d113bae4f",
+        "sha256_in_prefix": "b14c515d5823e7f6e4c67892fa376d54db748fab139c4d40db50f22d113bae4f",
+        "size_in_bytes": 200
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/US/Samoa",
+        "path_type": "hardlink",
+        "sha256": "e51fc51c65ffeab514d7636271157ee8941bdacf602cbc380f5d60b5fa674e87",
+        "sha256_in_prefix": "e51fc51c65ffeab514d7636271157ee8941bdacf602cbc380f5d60b5fa674e87",
+        "size_in_bytes": 188
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/UTC",
+        "path_type": "hardlink",
+        "sha256": "dee28ff84e3fc495ed3547d5e5e9fafdacc36a67329e747d434248ed45bf1755",
+        "sha256_in_prefix": "dee28ff84e3fc495ed3547d5e5e9fafdacc36a67329e747d434248ed45bf1755",
+        "size_in_bytes": 153
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Universal",
+        "path_type": "hardlink",
+        "sha256": "b7b0b82f471d64704e1d6f84646e6b7b2bd9cab793fad00f9c9b0595143c0ab7",
+        "sha256_in_prefix": "b7b0b82f471d64704e1d6f84646e6b7b2bd9cab793fad00f9c9b0595143c0ab7",
+        "size_in_bytes": 159
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/W-SU",
+        "path_type": "hardlink",
+        "sha256": "f7da75b585f45ab501b2889e272ff47b1c4a1d668e40aed7463eb0e8054028c2",
+        "sha256_in_prefix": "f7da75b585f45ab501b2889e272ff47b1c4a1d668e40aed7463eb0e8054028c2",
+        "size_in_bytes": 172
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/WET",
+        "path_type": "hardlink",
+        "sha256": "7e6e2369c19dd19a41be27bb8ad8df5be8b0096ed045c8b2c2d2f0916d494079",
+        "sha256_in_prefix": "7e6e2369c19dd19a41be27bb8ad8df5be8b0096ed045c8b2c2d2f0916d494079",
+        "size_in_bytes": 6945
+      },
+      {
+        "_path": "tcl/tcl8.6/tzdata/Zulu",
+        "path_type": "hardlink",
+        "sha256": "a06e8cccf97cc8fb545dfdb4c89b5e5c8edf0360547bdc1823b4ac47b1556c31",
+        "sha256_in_prefix": "a06e8cccf97cc8fb545dfdb4c89b5e5c8edf0360547bdc1823b4ac47b1556c31",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "tcl/tcl8.6/word.tcl",
+        "path_type": "hardlink",
+        "sha256": "678f891615e2209a8ecba17857922a9723e78709adb983032e89ca706000c44d",
+        "sha256_in_prefix": "678f891615e2209a8ecba17857922a9723e78709adb983032e89ca706000c44d",
+        "size_in_bytes": 5030
+      },
+      {
+        "_path": "tcl/tcl8/8.4/platform-1.0.18.tm",
+        "path_type": "hardlink",
+        "sha256": "c96140d154c3bdc0a13a06c8b8b7628dfcd014df827704d1dbcb2b3b38349605",
+        "sha256_in_prefix": "c96140d154c3bdc0a13a06c8b8b7628dfcd014df827704d1dbcb2b3b38349605",
+        "size_in_bytes": 11423
+      },
+      {
+        "_path": "tcl/tcl8/8.4/platform/shell-1.1.4.tm",
+        "path_type": "hardlink",
+        "sha256": "0a6b4b109cfdfc4b40fbdefdb2282f9b1af3cc2f9624dd39958eebd78781afb2",
+        "sha256_in_prefix": "0a6b4b109cfdfc4b40fbdefdb2282f9b1af3cc2f9624dd39958eebd78781afb2",
+        "size_in_bytes": 6218
+      },
+      {
+        "_path": "tcl/tcl8/8.5/msgcat-1.6.1.tm",
+        "path_type": "hardlink",
+        "sha256": "6774519f179872ec5292523f2788b77b2b839e15665037e097a0d4edddd1c6fb",
+        "sha256_in_prefix": "6774519f179872ec5292523f2788b77b2b839e15665037e097a0d4edddd1c6fb",
+        "size_in_bytes": 35136
+      },
+      {
+        "_path": "tcl/tcl8/8.5/tcltest-2.5.3.tm",
+        "path_type": "hardlink",
+        "sha256": "f6931f88ae2a4e63d77eec83e58f5944d66c7ef5f335a51064e8023e0c842971",
+        "sha256_in_prefix": "f6931f88ae2a4e63d77eec83e58f5944d66c7ef5f335a51064e8023e0c842971",
+        "size_in_bytes": 107041
+      },
+      {
+        "_path": "tcl/tcl8/8.6/http-2.9.5.tm",
+        "path_type": "hardlink",
+        "sha256": "226347b0fae4a3ed9237ce64c998c2a88b4fdd3d7f85a081b7cab3e863feb13d",
+        "sha256_in_prefix": "226347b0fae4a3ed9237ce64c998c2a88b4fdd3d7f85a081b7cab3e863feb13d",
+        "size_in_bytes": 115215
+      },
+      {
+        "_path": "tcl/tcl86t.lib",
+        "path_type": "hardlink",
+        "sha256": "29d65ab5e5c70edd2d65d560971493ef760827ba223faedcf0740a011bc6c88e",
+        "sha256_in_prefix": "29d65ab5e5c70edd2d65d560971493ef760827ba223faedcf0740a011bc6c88e",
+        "size_in_bytes": 185936
+      },
+      {
+        "_path": "tcl/tclConfig.sh",
+        "path_type": "hardlink",
+        "sha256": "1924c93f3bbe7bdd32a3598c13ba6ed31d307d0da2ffda116ec3e5c03c472cd9",
+        "sha256_in_prefix": "1924c93f3bbe7bdd32a3598c13ba6ed31d307d0da2ffda116ec3e5c03c472cd9",
+        "size_in_bytes": 7731
+      },
+      {
+        "_path": "tcl/tclooConfig.sh",
+        "path_type": "hardlink",
+        "sha256": "f4d7d687dac5033b04bcf6c9cf3014b8139c79e730f6c431c437108a9bb3ceeb",
+        "sha256_in_prefix": "f4d7d687dac5033b04bcf6c9cf3014b8139c79e730f6c431c437108a9bb3ceeb",
+        "size_in_bytes": 792
+      },
+      {
+        "_path": "tcl/tclstub86.lib",
+        "path_type": "hardlink",
+        "sha256": "22c7537b4d69ab562ec22736e75506512636ef84aeae0fbbea911c8a1891cc77",
+        "sha256_in_prefix": "22c7537b4d69ab562ec22736e75506512636ef84aeae0fbbea911c8a1891cc77",
+        "size_in_bytes": 9464
+      },
+      {
+        "_path": "tcl/tix8.4.3/Balloon.tcl",
+        "path_type": "hardlink",
+        "sha256": "8d859fad46257a6ce45170ec2740bda483ae71d1cae244bb6d605b8fb0397a35",
+        "sha256_in_prefix": "8d859fad46257a6ce45170ec2740bda483ae71d1cae244bb6d605b8fb0397a35",
+        "size_in_bytes": 13870
+      },
+      {
+        "_path": "tcl/tix8.4.3/BtnBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "e7d18e16f26125a2bdb3c972aac52897a7d3e8630a0da541916bffcfcdafa624",
+        "sha256_in_prefix": "e7d18e16f26125a2bdb3c972aac52897a7d3e8630a0da541916bffcfcdafa624",
+        "size_in_bytes": 2791
+      },
+      {
+        "_path": "tcl/tix8.4.3/CObjView.tcl",
+        "path_type": "hardlink",
+        "sha256": "6fc5e7d99e1eac0bc9ade139c76bc8d0fce72760ecd500d43cf390e69d6e5118",
+        "sha256_in_prefix": "6fc5e7d99e1eac0bc9ade139c76bc8d0fce72760ecd500d43cf390e69d6e5118",
+        "size_in_bytes": 8098
+      },
+      {
+        "_path": "tcl/tix8.4.3/ChkList.tcl",
+        "path_type": "hardlink",
+        "sha256": "c60d13aa1304a2fadf5abe57ae426c5ce92b5d88eabb4f9d088a58d75966f4f2",
+        "sha256_in_prefix": "c60d13aa1304a2fadf5abe57ae426c5ce92b5d88eabb4f9d088a58d75966f4f2",
+        "size_in_bytes": 5326
+      },
+      {
+        "_path": "tcl/tix8.4.3/ComboBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "c794fd78fc3ceecbe92f021526750c6640a34bc38b361f55f84b97f64a34a15d",
+        "sha256_in_prefix": "c794fd78fc3ceecbe92f021526750c6640a34bc38b361f55f84b97f64a34a15d",
+        "size_in_bytes": 37829
+      },
+      {
+        "_path": "tcl/tix8.4.3/Compat.tcl",
+        "path_type": "hardlink",
+        "sha256": "d225201425fa2345b1014561a039140f24c3503c47d621fa38f07be72d40726b",
+        "sha256_in_prefix": "d225201425fa2345b1014561a039140f24c3503c47d621fa38f07be72d40726b",
+        "size_in_bytes": 903
+      },
+      {
+        "_path": "tcl/tix8.4.3/Console.tcl",
+        "path_type": "hardlink",
+        "sha256": "98e52fb9406b39ba950106b69a137506022868fdc34e34539aa38d5e86aad2a5",
+        "sha256_in_prefix": "98e52fb9406b39ba950106b69a137506022868fdc34e34539aa38d5e86aad2a5",
+        "size_in_bytes": 15923
+      },
+      {
+        "_path": "tcl/tix8.4.3/Control.tcl",
+        "path_type": "hardlink",
+        "sha256": "053533c4fa7798d427252714834fa3f0645bca63ca26f2492a44efab87342afa",
+        "sha256_in_prefix": "053533c4fa7798d427252714834fa3f0645bca63ca26f2492a44efab87342afa",
+        "size_in_bytes": 12884
+      },
+      {
+        "_path": "tcl/tix8.4.3/DefSchm.tcl",
+        "path_type": "hardlink",
+        "sha256": "88c55e1607aa54af15d8926df4eb3a53e4db3145c0db2cfa179bee78cdf87755",
+        "sha256_in_prefix": "88c55e1607aa54af15d8926df4eb3a53e4db3145c0db2cfa179bee78cdf87755",
+        "size_in_bytes": 3116
+      },
+      {
+        "_path": "tcl/tix8.4.3/DialogS.tcl",
+        "path_type": "hardlink",
+        "sha256": "0101a4a368908409e8d2ee3cbf4dad1691b28ae68354676002962e4ba6de31fa",
+        "sha256_in_prefix": "0101a4a368908409e8d2ee3cbf4dad1691b28ae68354676002962e4ba6de31fa",
+        "size_in_bytes": 4471
+      },
+      {
+        "_path": "tcl/tix8.4.3/DirBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "ce99218b3ac5eaff04883f0ab4e7f6aec39c9c7f13b2a9ada78b8b6b257fa702",
+        "sha256_in_prefix": "ce99218b3ac5eaff04883f0ab4e7f6aec39c9c7f13b2a9ada78b8b6b257fa702",
+        "size_in_bytes": 5632
+      },
+      {
+        "_path": "tcl/tix8.4.3/DirDlg.tcl",
+        "path_type": "hardlink",
+        "sha256": "22185ff1362e6a9be6f363d096503bbd4dc120ba6c64e562c6c15ec5699754e9",
+        "sha256_in_prefix": "22185ff1362e6a9be6f363d096503bbd4dc120ba6c64e562c6c15ec5699754e9",
+        "size_in_bytes": 2301
+      },
+      {
+        "_path": "tcl/tix8.4.3/DirList.tcl",
+        "path_type": "hardlink",
+        "sha256": "8447068c3dfff842005c7d40103b90fa7707d3b1818f6f0cc7385dafd9f54ec5",
+        "sha256_in_prefix": "8447068c3dfff842005c7d40103b90fa7707d3b1818f6f0cc7385dafd9f54ec5",
+        "size_in_bytes": 7336
+      },
+      {
+        "_path": "tcl/tix8.4.3/DirTree.tcl",
+        "path_type": "hardlink",
+        "sha256": "fadec5d82ab5755f5a9461e5c6eb9d5a2a6cac4d5aa7bf6e70ac0989cdf9e30f",
+        "sha256_in_prefix": "fadec5d82ab5755f5a9461e5c6eb9d5a2a6cac4d5aa7bf6e70ac0989cdf9e30f",
+        "size_in_bytes": 9322
+      },
+      {
+        "_path": "tcl/tix8.4.3/DragDrop.tcl",
+        "path_type": "hardlink",
+        "sha256": "3eb7eaefe9e626ddf9f13ff022a325bcaad3433adcf0528d076a89d3c93b6b3d",
+        "sha256_in_prefix": "3eb7eaefe9e626ddf9f13ff022a325bcaad3433adcf0528d076a89d3c93b6b3d",
+        "size_in_bytes": 4191
+      },
+      {
+        "_path": "tcl/tix8.4.3/DtlList.tcl",
+        "path_type": "hardlink",
+        "sha256": "4173db98595abf7ad6082192e147d21274f6d6d240f97a32b229aa573849bb1e",
+        "sha256_in_prefix": "4173db98595abf7ad6082192e147d21274f6d6d240f97a32b229aa573849bb1e",
+        "size_in_bytes": 1051
+      },
+      {
+        "_path": "tcl/tix8.4.3/EFileBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "26bec1eb5d705e17f4700e0889ec902417b50dec5a9570e5225216d413d0d115",
+        "sha256_in_prefix": "26bec1eb5d705e17f4700e0889ec902417b50dec5a9570e5225216d413d0d115",
+        "size_in_bytes": 11826
+      },
+      {
+        "_path": "tcl/tix8.4.3/EFileDlg.tcl",
+        "path_type": "hardlink",
+        "sha256": "e52a51a4dfa9ecea0b57010407ef5584363d947d6eaf417e1ff404876050372a",
+        "sha256_in_prefix": "e52a51a4dfa9ecea0b57010407ef5584363d947d6eaf417e1ff404876050372a",
+        "size_in_bytes": 1783
+      },
+      {
+        "_path": "tcl/tix8.4.3/Event.tcl",
+        "path_type": "hardlink",
+        "sha256": "9519af49109264b006305ece5f6847f1e7b82e6f88812174d1d7be6d8e00db9e",
+        "sha256_in_prefix": "9519af49109264b006305ece5f6847f1e7b82e6f88812174d1d7be6d8e00db9e",
+        "size_in_bytes": 5448
+      },
+      {
+        "_path": "tcl/tix8.4.3/FileBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "b7c9c936e2cf490272a9b0f821c36cb3bb58f251b428e74c071cea9b31a1b726",
+        "sha256_in_prefix": "b7c9c936e2cf490272a9b0f821c36cb3bb58f251b428e74c071cea9b31a1b726",
+        "size_in_bytes": 14904
+      },
+      {
+        "_path": "tcl/tix8.4.3/FileCbx.tcl",
+        "path_type": "hardlink",
+        "sha256": "6c00108d75ef779467551dad23e141a7a670050d3320d4765d1b0b56a8573258",
+        "sha256_in_prefix": "6c00108d75ef779467551dad23e141a7a670050d3320d4765d1b0b56a8573258",
+        "size_in_bytes": 2591
+      },
+      {
+        "_path": "tcl/tix8.4.3/FileDlg.tcl",
+        "path_type": "hardlink",
+        "sha256": "4ba9f99f0074b1e26a36b1dcee801850b795b422bc6716467d92a80dbc17a2b5",
+        "sha256_in_prefix": "4ba9f99f0074b1e26a36b1dcee801850b795b422bc6716467d92a80dbc17a2b5",
+        "size_in_bytes": 2260
+      },
+      {
+        "_path": "tcl/tix8.4.3/FileEnt.tcl",
+        "path_type": "hardlink",
+        "sha256": "29dd4c57ec57052045df06245ab582522a4e55eeed69036e9288e9c208e84b9f",
+        "sha256_in_prefix": "29dd4c57ec57052045df06245ab582522a4e55eeed69036e9288e9c208e84b9f",
+        "size_in_bytes": 7589
+      },
+      {
+        "_path": "tcl/tix8.4.3/FloatEnt.tcl",
+        "path_type": "hardlink",
+        "sha256": "1d042097dbe2a3b8940bacb8bb5f5746e52bb2cb224441859fea9d5a4bbc0074",
+        "sha256_in_prefix": "1d042097dbe2a3b8940bacb8bb5f5746e52bb2cb224441859fea9d5a4bbc0074",
+        "size_in_bytes": 3308
+      },
+      {
+        "_path": "tcl/tix8.4.3/Grid.tcl",
+        "path_type": "hardlink",
+        "sha256": "bf9dd6af9feb5f50c9c47766263d6a11e8780dd78644892518a4b7c8dfbfe412",
+        "sha256_in_prefix": "bf9dd6af9feb5f50c9c47766263d6a11e8780dd78644892518a4b7c8dfbfe412",
+        "size_in_bytes": 22787
+      },
+      {
+        "_path": "tcl/tix8.4.3/HList.tcl",
+        "path_type": "hardlink",
+        "sha256": "913020628f9116a78afd4f615f7eb707511a489499b4bfbfaf6eed76a052a3fa",
+        "sha256_in_prefix": "913020628f9116a78afd4f615f7eb707511a489499b4bfbfaf6eed76a052a3fa",
+        "size_in_bytes": 19065
+      },
+      {
+        "_path": "tcl/tix8.4.3/HListDD.tcl",
+        "path_type": "hardlink",
+        "sha256": "c3e2afae1e4d072934c8ee5ec2d6fff8a07515026a82122569b709915edeaa67",
+        "sha256_in_prefix": "c3e2afae1e4d072934c8ee5ec2d6fff8a07515026a82122569b709915edeaa67",
+        "size_in_bytes": 4704
+      },
+      {
+        "_path": "tcl/tix8.4.3/IconView.tcl",
+        "path_type": "hardlink",
+        "sha256": "f184720a70d0e71aaf6199304a6bb2073efa180571d097585dc7f219fa35a37a",
+        "sha256_in_prefix": "f184720a70d0e71aaf6199304a6bb2073efa180571d097585dc7f219fa35a37a",
+        "size_in_bytes": 6382
+      },
+      {
+        "_path": "tcl/tix8.4.3/Init.tcl",
+        "path_type": "hardlink",
+        "sha256": "69c1294fbf03f83d84c541efef1fdcb915f668de86532b00a793a33082b50b14",
+        "sha256_in_prefix": "69c1294fbf03f83d84c541efef1fdcb915f668de86532b00a793a33082b50b14",
+        "size_in_bytes": 6431
+      },
+      {
+        "_path": "tcl/tix8.4.3/LabEntry.tcl",
+        "path_type": "hardlink",
+        "sha256": "4e6fd36cd91d0cf5fa66ba426ac0d3d8d081bca1f2a63c4cdee9c7cfe1054ac1",
+        "sha256_in_prefix": "4e6fd36cd91d0cf5fa66ba426ac0d3d8d081bca1f2a63c4cdee9c7cfe1054ac1",
+        "size_in_bytes": 2229
+      },
+      {
+        "_path": "tcl/tix8.4.3/LabFrame.tcl",
+        "path_type": "hardlink",
+        "sha256": "ccbdb56014474f646ca69b8efff19183b1c46185c4b3de1ea5c6766107d1a853",
+        "sha256_in_prefix": "ccbdb56014474f646ca69b8efff19183b1c46185c4b3de1ea5c6766107d1a853",
+        "size_in_bytes": 1230
+      },
+      {
+        "_path": "tcl/tix8.4.3/LabWidg.tcl",
+        "path_type": "hardlink",
+        "sha256": "d7f6c2b4b93eb9969b8f40d6cb268abffd1d7ade4270016a7a4166489c837720",
+        "sha256_in_prefix": "d7f6c2b4b93eb9969b8f40d6cb268abffd1d7ade4270016a7a4166489c837720",
+        "size_in_bytes": 4108
+      },
+      {
+        "_path": "tcl/tix8.4.3/ListNBk.tcl",
+        "path_type": "hardlink",
+        "sha256": "868912a8bbb69d8ef266347c40955eeab186e60d83d1ba17cc28e305a1dbd14d",
+        "sha256_in_prefix": "868912a8bbb69d8ef266347c40955eeab186e60d83d1ba17cc28e305a1dbd14d",
+        "size_in_bytes": 3734
+      },
+      {
+        "_path": "tcl/tix8.4.3/Makefile",
+        "path_type": "hardlink",
+        "sha256": "ce1660f59b8eb4ef49b6659a839b98d833a163d4e48838cc40689b63b8e6e40f",
+        "sha256_in_prefix": "ce1660f59b8eb4ef49b6659a839b98d833a163d4e48838cc40689b63b8e6e40f",
+        "size_in_bytes": 66
+      },
+      {
+        "_path": "tcl/tix8.4.3/Meter.tcl",
+        "path_type": "hardlink",
+        "sha256": "69f2e71bf5030bc04efe0249ba153c19625faaa898c7c2fba82ff94e1ea4e19d",
+        "sha256_in_prefix": "69f2e71bf5030bc04efe0249ba153c19625faaa898c7c2fba82ff94e1ea4e19d",
+        "size_in_bytes": 3251
+      },
+      {
+        "_path": "tcl/tix8.4.3/MultView.tcl",
+        "path_type": "hardlink",
+        "sha256": "ed25f5447d10d516e063f76b124e56d5cf7d83f15aaa8e3997c966d6ef913247",
+        "sha256_in_prefix": "ed25f5447d10d516e063f76b124e56d5cf7d83f15aaa8e3997c966d6ef913247",
+        "size_in_bytes": 3861
+      },
+      {
+        "_path": "tcl/tix8.4.3/NoteBook.tcl",
+        "path_type": "hardlink",
+        "sha256": "7e0c454c4015be7807c8a5f3265f1bdf4df7711c55f6e17322fff716366509f0",
+        "sha256_in_prefix": "7e0c454c4015be7807c8a5f3265f1bdf4df7711c55f6e17322fff716366509f0",
+        "size_in_bytes": 6407
+      },
+      {
+        "_path": "tcl/tix8.4.3/OldUtil.tcl",
+        "path_type": "hardlink",
+        "sha256": "86608d55ba5a374e5f34c3d0309138c58658ce437072da5e470d9faf59bae712",
+        "sha256_in_prefix": "86608d55ba5a374e5f34c3d0309138c58658ce437072da5e470d9faf59bae712",
+        "size_in_bytes": 3164
+      },
+      {
+        "_path": "tcl/tix8.4.3/OptMenu.tcl",
+        "path_type": "hardlink",
+        "sha256": "d3b5df03dc0ef449d75e91acaaed9bd7e6a1d30cef079e5bd50479892e6b0a71",
+        "sha256_in_prefix": "d3b5df03dc0ef449d75e91acaaed9bd7e6a1d30cef079e5bd50479892e6b0a71",
+        "size_in_bytes": 9786
+      },
+      {
+        "_path": "tcl/tix8.4.3/PanedWin.tcl",
+        "path_type": "hardlink",
+        "sha256": "4883f6355fdcf66fe229f10cb33a2c5609cf2de7ac5e241875ad828f7add03aa",
+        "sha256_in_prefix": "4883f6355fdcf66fe229f10cb33a2c5609cf2de7ac5e241875ad828f7add03aa",
+        "size_in_bytes": 29562
+      },
+      {
+        "_path": "tcl/tix8.4.3/PopMenu.tcl",
+        "path_type": "hardlink",
+        "sha256": "2565b9f95ffb0aa2eddcdd1c5efd05f480deabba11425c217647504674f67628",
+        "sha256_in_prefix": "2565b9f95ffb0aa2eddcdd1c5efd05f480deabba11425c217647504674f67628",
+        "size_in_bytes": 5739
+      },
+      {
+        "_path": "tcl/tix8.4.3/Primitiv.tcl",
+        "path_type": "hardlink",
+        "sha256": "ef1ff46f0169258ae2f0ac0fd840d3f58231c6825060b787a3f0f8a5052752d9",
+        "sha256_in_prefix": "ef1ff46f0169258ae2f0ac0fd840d3f58231c6825060b787a3f0f8a5052752d9",
+        "size_in_bytes": 10955
+      },
+      {
+        "_path": "tcl/tix8.4.3/ResizeH.tcl",
+        "path_type": "hardlink",
+        "sha256": "9cd973d3de2385a0f665ce1c8bf2a8ada490f6eb396a4e620dce31e72a0d120f",
+        "sha256_in_prefix": "9cd973d3de2385a0f665ce1c8bf2a8ada490f6eb396a4e620dce31e72a0d120f",
+        "size_in_bytes": 13752
+      },
+      {
+        "_path": "tcl/tix8.4.3/SGrid.tcl",
+        "path_type": "hardlink",
+        "sha256": "eb657acb453c6e4c2e60edcae955b76ec61f07951186f14b901d35a6163922fc",
+        "sha256_in_prefix": "eb657acb453c6e4c2e60edcae955b76ec61f07951186f14b901d35a6163922fc",
+        "size_in_bytes": 6178
+      },
+      {
+        "_path": "tcl/tix8.4.3/SHList.tcl",
+        "path_type": "hardlink",
+        "sha256": "b16b5135862e52f427d684ec6507b6d13426575fe80b4efbbe2e6ba70579bde9",
+        "sha256_in_prefix": "b16b5135862e52f427d684ec6507b6d13426575fe80b4efbbe2e6ba70579bde9",
+        "size_in_bytes": 3933
+      },
+      {
+        "_path": "tcl/tix8.4.3/SListBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "5a223998f63d38ec72bf3e9933e7aec7761bdf7b41b07a0b533eb82085af1e05",
+        "sha256_in_prefix": "5a223998f63d38ec72bf3e9933e7aec7761bdf7b41b07a0b533eb82085af1e05",
+        "size_in_bytes": 7433
+      },
+      {
+        "_path": "tcl/tix8.4.3/STList.tcl",
+        "path_type": "hardlink",
+        "sha256": "4b8b15a65b697f7417b2b37e8dcea0b182d5ed243d968ee744a2e6537691518b",
+        "sha256_in_prefix": "4b8b15a65b697f7417b2b37e8dcea0b182d5ed243d968ee744a2e6537691518b",
+        "size_in_bytes": 2521
+      },
+      {
+        "_path": "tcl/tix8.4.3/SText.tcl",
+        "path_type": "hardlink",
+        "sha256": "2682daa8f67c0438696d365284e7cdd57c7c461462b15756755ad5281afec44f",
+        "sha256_in_prefix": "2682daa8f67c0438696d365284e7cdd57c7c461462b15756755ad5281afec44f",
+        "size_in_bytes": 3297
+      },
+      {
+        "_path": "tcl/tix8.4.3/SWidget.tcl",
+        "path_type": "hardlink",
+        "sha256": "7965659057591e4bc091fa276fdfd58670d99d70d264e4a54ac74c3a80e84e04",
+        "sha256_in_prefix": "7965659057591e4bc091fa276fdfd58670d99d70d264e4a54ac74c3a80e84e04",
+        "size_in_bytes": 10213
+      },
+      {
+        "_path": "tcl/tix8.4.3/SWindow.tcl",
+        "path_type": "hardlink",
+        "sha256": "13e80a6d76aeb91e2fbf5d36d831f3cde55e7b8f54ea5611c5c49fa648179339",
+        "sha256_in_prefix": "13e80a6d76aeb91e2fbf5d36d831f3cde55e7b8f54ea5611c5c49fa648179339",
+        "size_in_bytes": 7182
+      },
+      {
+        "_path": "tcl/tix8.4.3/Select.tcl",
+        "path_type": "hardlink",
+        "sha256": "b67b23f24c5f4334bb9da6c0db8fd664f2903879ca64bd1804993df9e1635af8",
+        "sha256_in_prefix": "b67b23f24c5f4334bb9da6c0db8fd664f2903879ca64bd1804993df9e1635af8",
+        "size_in_bytes": 7504
+      },
+      {
+        "_path": "tcl/tix8.4.3/Shell.tcl",
+        "path_type": "hardlink",
+        "sha256": "f23170ab8c06c831c16d4437abfe5937fedd3e4810ed5bc1be39b1c73c6efe7d",
+        "sha256_in_prefix": "f23170ab8c06c831c16d4437abfe5937fedd3e4810ed5bc1be39b1c73c6efe7d",
+        "size_in_bytes": 1129
+      },
+      {
+        "_path": "tcl/tix8.4.3/SimpDlg.tcl",
+        "path_type": "hardlink",
+        "sha256": "a937709b31c0c7da5f3fac25a962945755c64a1aab66f226f09d28fcaa4b78b0",
+        "sha256_in_prefix": "a937709b31c0c7da5f3fac25a962945755c64a1aab66f226f09d28fcaa4b78b0",
+        "size_in_bytes": 1204
+      },
+      {
+        "_path": "tcl/tix8.4.3/StackWin.tcl",
+        "path_type": "hardlink",
+        "sha256": "6a959445d5f7257e471275328a965de8c65cd89d6bc6fabe8008ee2bff3a75eb",
+        "sha256_in_prefix": "6a959445d5f7257e471275328a965de8c65cd89d6bc6fabe8008ee2bff3a75eb",
+        "size_in_bytes": 2076
+      },
+      {
+        "_path": "tcl/tix8.4.3/StatBar.tcl",
+        "path_type": "hardlink",
+        "sha256": "879632d5829f53a37efb21bc953eaebe353983bf0a56fd94b42cb83e57fefec6",
+        "sha256_in_prefix": "879632d5829f53a37efb21bc953eaebe353983bf0a56fd94b42cb83e57fefec6",
+        "size_in_bytes": 1395
+      },
+      {
+        "_path": "tcl/tix8.4.3/StdBBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "84a04d9dfa793893de0ac79577b6e3d7e73bf6b587de122b486355b12de4f467",
+        "sha256_in_prefix": "84a04d9dfa793893de0ac79577b6e3d7e73bf6b587de122b486355b12de4f467",
+        "size_in_bytes": 1727
+      },
+      {
+        "_path": "tcl/tix8.4.3/StdShell.tcl",
+        "path_type": "hardlink",
+        "sha256": "aeba32e5813152fc4318068d5a6f5d40f68fea5124c981b8520d829057d21b26",
+        "sha256_in_prefix": "aeba32e5813152fc4318068d5a6f5d40f68fea5124c981b8520d829057d21b26",
+        "size_in_bytes": 1222
+      },
+      {
+        "_path": "tcl/tix8.4.3/TList.tcl",
+        "path_type": "hardlink",
+        "sha256": "3e6a976cc1fee5512cedb6ebe8c2d41af922b5650c0ea183e694a3da691dc44c",
+        "sha256_in_prefix": "3e6a976cc1fee5512cedb6ebe8c2d41af922b5650c0ea183e694a3da691dc44c",
+        "size_in_bytes": 18962
+      },
+      {
+        "_path": "tcl/tix8.4.3/Tix.tcl",
+        "path_type": "hardlink",
+        "sha256": "63fc95a796f3cca4c7f91545e22370b09e52321fc5505379fb4769c22d565bbe",
+        "sha256_in_prefix": "63fc95a796f3cca4c7f91545e22370b09e52321fc5505379fb4769c22d565bbe",
+        "size_in_bytes": 10135
+      },
+      {
+        "_path": "tcl/tix8.4.3/Tree.tcl",
+        "path_type": "hardlink",
+        "sha256": "c5bee47b3ad77318370f226fb9199b2330f8ac2de156b37da09dfdffdcb7ef96",
+        "sha256_in_prefix": "c5bee47b3ad77318370f226fb9199b2330f8ac2de156b37da09dfdffdcb7ef96",
+        "size_in_bytes": 4890
+      },
+      {
+        "_path": "tcl/tix8.4.3/Utils.tcl",
+        "path_type": "hardlink",
+        "sha256": "e879818465f3b7eb33c6121d7f104b1342ee2dc04a2968a112d2c6db620ee903",
+        "sha256_in_prefix": "e879818465f3b7eb33c6121d7f104b1342ee2dc04a2968a112d2c6db620ee903",
+        "size_in_bytes": 11230
+      },
+      {
+        "_path": "tcl/tix8.4.3/VResize.tcl",
+        "path_type": "hardlink",
+        "sha256": "a5b2edeb99e70cbeff4b7322b6a8958334330d23c1f178fe2ef1a7ad2de4ee33",
+        "sha256_in_prefix": "a5b2edeb99e70cbeff4b7322b6a8958334330d23c1f178fe2ef1a7ad2de4ee33",
+        "size_in_bytes": 5280
+      },
+      {
+        "_path": "tcl/tix8.4.3/VStack.tcl",
+        "path_type": "hardlink",
+        "sha256": "74793e12d762da6483d955f4d3e32096f093906e51e69916b5c383bab663b019",
+        "sha256_in_prefix": "74793e12d762da6483d955f4d3e32096f093906e51e69916b5c383bab663b019",
+        "size_in_bytes": 10081
+      },
+      {
+        "_path": "tcl/tix8.4.3/VTree.tcl",
+        "path_type": "hardlink",
+        "sha256": "e3f96013e5bc6342a8b2023b1eed5b5688dd8e2c84ba1bfd12719162deb9675f",
+        "sha256_in_prefix": "e3f96013e5bc6342a8b2023b1eed5b5688dd8e2c84ba1bfd12719162deb9675f",
+        "size_in_bytes": 4605
+      },
+      {
+        "_path": "tcl/tix8.4.3/Variable.tcl",
+        "path_type": "hardlink",
+        "sha256": "b7449919f74570a9a60453a5e85c9996342b50cf922bb9d643ee81b680c21ed4",
+        "sha256_in_prefix": "b7449919f74570a9a60453a5e85c9996342b50cf922bb9d643ee81b680c21ed4",
+        "size_in_bytes": 2664
+      },
+      {
+        "_path": "tcl/tix8.4.3/WInfo.tcl",
+        "path_type": "hardlink",
+        "sha256": "83caabac9926ac5a7cf5dee949199e721f79fadffd1b8a7f81f7f634f658b0ee",
+        "sha256_in_prefix": "83caabac9926ac5a7cf5dee949199e721f79fadffd1b8a7f81f7f634f658b0ee",
+        "size_in_bytes": 1005
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/act_fold.gif",
+        "path_type": "hardlink",
+        "sha256": "486a8b71c0f9241a5bff2b275e8f011349076bf4fdd777ed1458eb050c0633bb",
+        "sha256_in_prefix": "486a8b71c0f9241a5bff2b275e8f011349076bf4fdd777ed1458eb050c0633bb",
+        "size_in_bytes": 90
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/act_fold.xbm",
+        "path_type": "hardlink",
+        "sha256": "7feb01403909a62e682c5a2832dd1f63d11fcf847c0abf0bd2e11b6acde589b1",
+        "sha256_in_prefix": "7feb01403909a62e682c5a2832dd1f63d11fcf847c0abf0bd2e11b6acde589b1",
+        "size_in_bytes": 226
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/act_fold.xpm",
+        "path_type": "hardlink",
+        "sha256": "4a636d32b87244f7948859eee4acd512d85ec245cd5a81c8cbeb4fe12b8d74ce",
+        "sha256_in_prefix": "4a636d32b87244f7948859eee4acd512d85ec245cd5a81c8cbeb4fe12b8d74ce",
+        "size_in_bytes": 458
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/balarrow.xbm",
+        "path_type": "hardlink",
+        "sha256": "ed4c68519e2d603725cec0f0d892c740a257ec2f38cf0344ec819abd62e9b26a",
+        "sha256_in_prefix": "ed4c68519e2d603725cec0f0d892c740a257ec2f38cf0344ec819abd62e9b26a",
+        "size_in_bytes": 127
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/cbxarrow.xbm",
+        "path_type": "hardlink",
+        "sha256": "ce68aac68ba116cfb47b9f3556c058ce30c92f0832341c2632c9cd4d8be8ad5f",
+        "sha256_in_prefix": "ce68aac68ba116cfb47b9f3556c058ce30c92f0832341c2632c9cd4d8be8ad5f",
+        "size_in_bytes": 269
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/ck_def.xbm",
+        "path_type": "hardlink",
+        "sha256": "592d27ca23ad113c37a16e7da7d67ea28a51571fe24a8baca4838915ddcba641",
+        "sha256_in_prefix": "592d27ca23ad113c37a16e7da7d67ea28a51571fe24a8baca4838915ddcba641",
+        "size_in_bytes": 260
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/ck_off.xbm",
+        "path_type": "hardlink",
+        "sha256": "b9d25190c0042f8f25ab0539424df8adeddb5f12bcb9c8ef7d0039ce63cdb93b",
+        "sha256_in_prefix": "b9d25190c0042f8f25ab0539424df8adeddb5f12bcb9c8ef7d0039ce63cdb93b",
+        "size_in_bytes": 260
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/ck_on.xbm",
+        "path_type": "hardlink",
+        "sha256": "6fdf18b2c0603c9c6db89134ca7baec9bd3bdfd58f6f592c74614cd81053cadc",
+        "sha256_in_prefix": "6fdf18b2c0603c9c6db89134ca7baec9bd3bdfd58f6f592c74614cd81053cadc",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/cross.xbm",
+        "path_type": "hardlink",
+        "sha256": "b6a9a5a3ef3742bc0f601a0aae673f00e1a88f0b999fa7d6b620473164db2aab",
+        "sha256_in_prefix": "b6a9a5a3ef3742bc0f601a0aae673f00e1a88f0b999fa7d6b620473164db2aab",
+        "size_in_bytes": 260
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/decr.xbm",
+        "path_type": "hardlink",
+        "sha256": "ed764b336a07336d12dd28f0a75940b2e2d47a23ad8371c377560e91bcab192c",
+        "sha256_in_prefix": "ed764b336a07336d12dd28f0a75940b2e2d47a23ad8371c377560e91bcab192c",
+        "size_in_bytes": 103
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/drop.xbm",
+        "path_type": "hardlink",
+        "sha256": "9a896927b99efa61981b769bc685e6d411180fe31dc4979fa5d576fc1c7e26dc",
+        "sha256_in_prefix": "9a896927b99efa61981b769bc685e6d411180fe31dc4979fa5d576fc1c7e26dc",
+        "size_in_bytes": 334
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/file.gif",
+        "path_type": "hardlink",
+        "sha256": "1ad2fbc604ec60116849574bc4dc371f8cb5796e14571ea2684c8bab99b4c467",
+        "sha256_in_prefix": "1ad2fbc604ec60116849574bc4dc371f8cb5796e14571ea2684c8bab99b4c467",
+        "size_in_bytes": 76
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/file.xbm",
+        "path_type": "hardlink",
+        "sha256": "ef733ad2da584a41a4d1bf5525e080c60a5f2f332e7d583ab0003d23e1cdcb71",
+        "sha256_in_prefix": "ef733ad2da584a41a4d1bf5525e080c60a5f2f332e7d583ab0003d23e1cdcb71",
+        "size_in_bytes": 238
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/file.xpm",
+        "path_type": "hardlink",
+        "sha256": "520e7d4a55e1ab59720faf0a7bf31e54fc3b50f3b569c38c458d1943bf0bf731",
+        "sha256_in_prefix": "520e7d4a55e1ab59720faf0a7bf31e54fc3b50f3b569c38c458d1943bf0bf731",
+        "size_in_bytes": 316
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/folder.gif",
+        "path_type": "hardlink",
+        "sha256": "4e03a2fe3cd8a5d64eb924d1561ff838f473c10c3d8d97fbde6762f3a1b44611",
+        "sha256_in_prefix": "4e03a2fe3cd8a5d64eb924d1561ff838f473c10c3d8d97fbde6762f3a1b44611",
+        "size_in_bytes": 79
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/folder.xbm",
+        "path_type": "hardlink",
+        "sha256": "e7d82aab810ced6c2026994de6caf5cfa7c2aeba2349701fe914f1dc9ee59378",
+        "sha256_in_prefix": "e7d82aab810ced6c2026994de6caf5cfa7c2aeba2349701fe914f1dc9ee59378",
+        "size_in_bytes": 220
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/folder.xpm",
+        "path_type": "hardlink",
+        "sha256": "797aba91bc16d98770751cd17b44a9d40758c442f251e2155b77ca1c42e32ccd",
+        "sha256_in_prefix": "797aba91bc16d98770751cd17b44a9d40758c442f251e2155b77ca1c42e32ccd",
+        "size_in_bytes": 439
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/harddisk.xbm",
+        "path_type": "hardlink",
+        "sha256": "0112cd468574b726ee78db9eb9e104882705a204f942ddae14f3c5df2b3987be",
+        "sha256_in_prefix": "0112cd468574b726ee78db9eb9e104882705a204f942ddae14f3c5df2b3987be",
+        "size_in_bytes": 910
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/hourglas.mask",
+        "path_type": "hardlink",
+        "sha256": "4be19ef1f480d8dfa650c3d0ed635a34d5b08da3a8f9726f28c91834d967272c",
+        "sha256_in_prefix": "4be19ef1f480d8dfa650c3d0ed635a34d5b08da3a8f9726f28c91834d967272c",
+        "size_in_bytes": 985
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/hourglas.xbm",
+        "path_type": "hardlink",
+        "sha256": "8ab90aa067db1aedd294b46fa7f47c2320e4a4c5c922445436d7fcc2ec1239a5",
+        "sha256_in_prefix": "8ab90aa067db1aedd294b46fa7f47c2320e4a4c5c922445436d7fcc2ec1239a5",
+        "size_in_bytes": 956
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/incr.xbm",
+        "path_type": "hardlink",
+        "sha256": "12fd1f428aaf57523785319da1df9f6271c86f44adaea467f5020688facc7101",
+        "sha256_in_prefix": "12fd1f428aaf57523785319da1df9f6271c86f44adaea467f5020688facc7101",
+        "size_in_bytes": 103
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/info.gif",
+        "path_type": "hardlink",
+        "sha256": "b007a8c582991388b12891a8b46445de6809ef6d52aaa43bf8d946ac8f9f6d43",
+        "sha256_in_prefix": "b007a8c582991388b12891a8b46445de6809ef6d52aaa43bf8d946ac8f9f6d43",
+        "size_in_bytes": 159
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/info.xpm",
+        "path_type": "hardlink",
+        "sha256": "60528b4c52b71859000a4688c93490f2c8ad60a4d53324c830cd011d123ebb3b",
+        "sha256_in_prefix": "60528b4c52b71859000a4688c93490f2c8ad60a4d53324c830cd011d123ebb3b",
+        "size_in_bytes": 1296
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/maximize.xbm",
+        "path_type": "hardlink",
+        "sha256": "120312587a98b09f2462b64684e9aafdc2407c8b15254a1c2b184e58aa518273",
+        "sha256_in_prefix": "120312587a98b09f2462b64684e9aafdc2407c8b15254a1c2b184e58aa518273",
+        "size_in_bytes": 290
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/minimize.xbm",
+        "path_type": "hardlink",
+        "sha256": "63e1b654a0a98a8e291093655eb15e385048134fd80506850b352b6f0df2b0a6",
+        "sha256_in_prefix": "63e1b654a0a98a8e291093655eb15e385048134fd80506850b352b6f0df2b0a6",
+        "size_in_bytes": 290
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/minus.gif",
+        "path_type": "hardlink",
+        "sha256": "401e41b99d8c8d2eafa41571b8d321aa419a4ca7ab8136fbe1b0adb86084d3a6",
+        "sha256_in_prefix": "401e41b99d8c8d2eafa41571b8d321aa419a4ca7ab8136fbe1b0adb86084d3a6",
+        "size_in_bytes": 57
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/minus.xbm",
+        "path_type": "hardlink",
+        "sha256": "e33fa6675c7ecd3df86d581a2d6618e1d311418312167185a7da4c60bb82c862",
+        "sha256_in_prefix": "e33fa6675c7ecd3df86d581a2d6618e1d311418312167185a7da4c60bb82c862",
+        "size_in_bytes": 203
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/minus.xpm",
+        "path_type": "hardlink",
+        "sha256": "a7980153da9b4706e1368f760950f50853739f1c6c29c4a59ab0c4df5f188a3f",
+        "sha256_in_prefix": "a7980153da9b4706e1368f760950f50853739f1c6c29c4a59ab0c4df5f188a3f",
+        "size_in_bytes": 215
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/minusarm.gif",
+        "path_type": "hardlink",
+        "sha256": "cfe867e18c427aa88d5e2404a01aa22d042212222e8304b25275a400e650d1d8",
+        "sha256_in_prefix": "cfe867e18c427aa88d5e2404a01aa22d042212222e8304b25275a400e650d1d8",
+        "size_in_bytes": 59
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/minusarm.xbm",
+        "path_type": "hardlink",
+        "sha256": "079c3e9257032eabb0f6e400b13540e5cbc93fecee5eeab58b463a2b5e2de279",
+        "sha256_in_prefix": "079c3e9257032eabb0f6e400b13540e5cbc93fecee5eeab58b463a2b5e2de279",
+        "size_in_bytes": 212
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/minusarm.xpm",
+        "path_type": "hardlink",
+        "sha256": "6a848c63bc2e49ebe2cff0518879a24c680f0322d672e0b171a709af317d3eb2",
+        "sha256_in_prefix": "6a848c63bc2e49ebe2cff0518879a24c680f0322d672e0b171a709af317d3eb2",
+        "size_in_bytes": 235
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/mktransgif.tcl",
+        "path_type": "hardlink",
+        "sha256": "e32db60b06f6c696668e9922c3f4494e6ae5e5987e0f7bf54e43d7ddeef92dfb",
+        "sha256_in_prefix": "e32db60b06f6c696668e9922c3f4494e6ae5e5987e0f7bf54e43d7ddeef92dfb",
+        "size_in_bytes": 263
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/network.xbm",
+        "path_type": "hardlink",
+        "sha256": "cd590da62995aee324d238ecfc8a018932cfb47f3b409c54c8ee141419c9993c",
+        "sha256_in_prefix": "cd590da62995aee324d238ecfc8a018932cfb47f3b409c54c8ee141419c9993c",
+        "size_in_bytes": 907
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/no_entry.gif",
+        "path_type": "hardlink",
+        "sha256": "5acb672d97f4adf4ae8d31b3968a1a17dfa66c35d74a1da262f14c12615d3f56",
+        "sha256_in_prefix": "5acb672d97f4adf4ae8d31b3968a1a17dfa66c35d74a1da262f14c12615d3f56",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/no_entry.xpm",
+        "path_type": "hardlink",
+        "sha256": "fbc7cf43867aa7cd42ab3b5ee444787aac11000bdd56ea1c612f287706e75201",
+        "sha256_in_prefix": "fbc7cf43867aa7cd42ab3b5ee444787aac11000bdd56ea1c612f287706e75201",
+        "size_in_bytes": 1313
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/openfile.xbm",
+        "path_type": "hardlink",
+        "sha256": "997e09f07f38db012faeb93ff9a2ecb797da126a033ee70bb4e53b40068ac887",
+        "sha256_in_prefix": "997e09f07f38db012faeb93ff9a2ecb797da126a033ee70bb4e53b40068ac887",
+        "size_in_bytes": 226
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/openfold.gif",
+        "path_type": "hardlink",
+        "sha256": "b1a7e8a341a1f795f0890116f68368ff4bb0f1e0ce73691719dc24e3927463ad",
+        "sha256_in_prefix": "b1a7e8a341a1f795f0890116f68368ff4bb0f1e0ce73691719dc24e3927463ad",
+        "size_in_bytes": 84
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/openfold.xbm",
+        "path_type": "hardlink",
+        "sha256": "93c13e84f98d290ef701259404220c081bdd319c03614a13cff23118dbdd08d8",
+        "sha256_in_prefix": "93c13e84f98d290ef701259404220c081bdd319c03614a13cff23118dbdd08d8",
+        "size_in_bytes": 226
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/openfold.xpm",
+        "path_type": "hardlink",
+        "sha256": "917ee346574fa9f63b0a407af52d44fb2a1645f870047599816d944c76105f47",
+        "sha256_in_prefix": "917ee346574fa9f63b0a407af52d44fb2a1645f870047599816d944c76105f47",
+        "size_in_bytes": 439
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/plus.gif",
+        "path_type": "hardlink",
+        "sha256": "16ea40fed8c12bbf64b072bacf6b1c8ca80ce26e08fee7860b98cc9cce44fa64",
+        "sha256_in_prefix": "16ea40fed8c12bbf64b072bacf6b1c8ca80ce26e08fee7860b98cc9cce44fa64",
+        "size_in_bytes": 58
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/plus.xbm",
+        "path_type": "hardlink",
+        "sha256": "38aabbddd20ce0f3cec8a4fae12076d3a6af6b66adbbe631b243df7c1905d372",
+        "sha256_in_prefix": "38aabbddd20ce0f3cec8a4fae12076d3a6af6b66adbbe631b243df7c1905d372",
+        "size_in_bytes": 200
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/plus.xpm",
+        "path_type": "hardlink",
+        "sha256": "f8a13e2dc9d1e2d64fc97a1459355035275eaef5246041ece0aa6433727fa213",
+        "sha256_in_prefix": "f8a13e2dc9d1e2d64fc97a1459355035275eaef5246041ece0aa6433727fa213",
+        "size_in_bytes": 214
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/plusarm.gif",
+        "path_type": "hardlink",
+        "sha256": "6fc4098826ca6e02ed0be4060014861e494913e6684abec63b022d60c1c73011",
+        "sha256_in_prefix": "6fc4098826ca6e02ed0be4060014861e494913e6684abec63b022d60c1c73011",
+        "size_in_bytes": 60
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/plusarm.xbm",
+        "path_type": "hardlink",
+        "sha256": "d203e21013532585774695fa825cc5e9fdd61cbb6d003d5a81ea5708f632943d",
+        "sha256_in_prefix": "d203e21013532585774695fa825cc5e9fdd61cbb6d003d5a81ea5708f632943d",
+        "size_in_bytes": 209
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/plusarm.xpm",
+        "path_type": "hardlink",
+        "sha256": "29028826c570486b84309eac36a44ff4ec075f4bc6524fcf670bb15a6ac2d9d3",
+        "sha256_in_prefix": "29028826c570486b84309eac36a44ff4ec075f4bc6524fcf670bb15a6ac2d9d3",
+        "size_in_bytes": 227
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/resize1.xbm",
+        "path_type": "hardlink",
+        "sha256": "e922248c4442f0dc2649395fa3daf6e632fe2535c80f0b08cf3e437da90c6a40",
+        "sha256_in_prefix": "e922248c4442f0dc2649395fa3daf6e632fe2535c80f0b08cf3e437da90c6a40",
+        "size_in_bytes": 313
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/resize2.xbm",
+        "path_type": "hardlink",
+        "sha256": "da1a4e91a087f0ba61ac8a6041e196cdcd83e4bf439ba40d184e35017961b70b",
+        "sha256_in_prefix": "da1a4e91a087f0ba61ac8a6041e196cdcd83e4bf439ba40d184e35017961b70b",
+        "size_in_bytes": 313
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/restore.xbm",
+        "path_type": "hardlink",
+        "sha256": "ef817004da4f01a79b2b7d938d9958b86bc20b3ce25d19ed67d4a73373781ad6",
+        "sha256_in_prefix": "ef817004da4f01a79b2b7d938d9958b86bc20b3ce25d19ed67d4a73373781ad6",
+        "size_in_bytes": 287
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/srcfile.gif",
+        "path_type": "hardlink",
+        "sha256": "36cb7cca5a262c77937b45b9ed3eac3cacc85181c133c45913fac7481221197d",
+        "sha256_in_prefix": "36cb7cca5a262c77937b45b9ed3eac3cacc85181c133c45913fac7481221197d",
+        "size_in_bytes": 79
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/srcfile.xbm",
+        "path_type": "hardlink",
+        "sha256": "369b3ab49934fc1042a6334c1582f98f5571e8dd946b371ab9eb62124608043a",
+        "sha256_in_prefix": "369b3ab49934fc1042a6334c1582f98f5571e8dd946b371ab9eb62124608043a",
+        "size_in_bytes": 247
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/srcfile.xpm",
+        "path_type": "hardlink",
+        "sha256": "3890463645a661c5de044fab923cd5e3ffa2a02869ba6f750230de74da58eb12",
+        "sha256_in_prefix": "3890463645a661c5de044fab923cd5e3ffa2a02869ba6f750230de74da58eb12",
+        "size_in_bytes": 312
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/system.xbm",
+        "path_type": "hardlink",
+        "sha256": "9b6cb3257d649d1f5fb3b244b9c1e69f0e0435421e8ebe1994097e1b4020b0fe",
+        "sha256_in_prefix": "9b6cb3257d649d1f5fb3b244b9c1e69f0e0435421e8ebe1994097e1b4020b0fe",
+        "size_in_bytes": 284
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/textfile.gif",
+        "path_type": "hardlink",
+        "sha256": "3b53a7da944e77d00ebb1b352ece6b6e50572e0222678087b86bb163a3969150",
+        "sha256_in_prefix": "3b53a7da944e77d00ebb1b352ece6b6e50572e0222678087b86bb163a3969150",
+        "size_in_bytes": 79
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/textfile.xbm",
+        "path_type": "hardlink",
+        "sha256": "b5dca68ab0947b6c797ba946911b3925fded77a97992079bda14b81a338c799f",
+        "sha256_in_prefix": "b5dca68ab0947b6c797ba946911b3925fded77a97992079bda14b81a338c799f",
+        "size_in_bytes": 250
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/textfile.xpm",
+        "path_type": "hardlink",
+        "sha256": "6d30e5711ba26d348c2fe18c510fd4997d1a9e78e32085060f0ccd87674a0bfc",
+        "sha256_in_prefix": "6d30e5711ba26d348c2fe18c510fd4997d1a9e78e32085060f0ccd87674a0bfc",
+        "size_in_bytes": 320
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/tick.xbm",
+        "path_type": "hardlink",
+        "sha256": "70920a3c0f5135827ccea0b18368f330dca166b6c1530d687a6d85a7f4d24276",
+        "sha256_in_prefix": "70920a3c0f5135827ccea0b18368f330dca166b6c1530d687a6d85a7f4d24276",
+        "size_in_bytes": 257
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/warning.gif",
+        "path_type": "hardlink",
+        "sha256": "4855ae49469c2c9aa238564d41c57e75ccd4a391156b273a042096382cd3c732",
+        "sha256_in_prefix": "4855ae49469c2c9aa238564d41c57e75ccd4a391156b273a042096382cd3c732",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "tcl/tix8.4.3/bitmaps/warning.xpm",
+        "path_type": "hardlink",
+        "sha256": "a74c0abaa65318caa8d118955ac0cce9c81e585ae2079c635c16d911debbf3fa",
+        "sha256_in_prefix": "a74c0abaa65318caa8d118955ac0cce9c81e585ae2079c635c16d911debbf3fa",
+        "size_in_bytes": 1300
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/MkChoose.tcl",
+        "path_type": "hardlink",
+        "sha256": "15855b365f76e23cec3629ad97d7fc52ba673538026d11851cf59d2f725d0443",
+        "sha256_in_prefix": "15855b365f76e23cec3629ad97d7fc52ba673538026d11851cf59d2f725d0443",
+        "size_in_bytes": 9221
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/MkDirLis.tcl",
+        "path_type": "hardlink",
+        "sha256": "1f55ab4debd9928f5735e6b819fa9e59461649e69aa708c94ab617e4c3068c3c",
+        "sha256_in_prefix": "1f55ab4debd9928f5735e6b819fa9e59461649e69aa708c94ab617e4c3068c3c",
+        "size_in_bytes": 2087
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/MkSample.tcl",
+        "path_type": "hardlink",
+        "sha256": "3fa4e078758eb8a77158b9b7136aa8608f23753a0e541f97082c434508eefab3",
+        "sha256_in_prefix": "3fa4e078758eb8a77158b9b7136aa8608f23753a0e541f97082c434508eefab3",
+        "size_in_bytes": 7008
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/MkScroll.tcl",
+        "path_type": "hardlink",
+        "sha256": "73ebeeca09e42a09b52b9b9cda74dc7b1442189e55d695e40f080111bae5d1b4",
+        "sha256_in_prefix": "73ebeeca09e42a09b52b9b9cda74dc7b1442189e55d695e40f080111bae5d1b4",
+        "size_in_bytes": 5283
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/about.xpm",
+        "path_type": "hardlink",
+        "sha256": "24805c306d3a88dc8274fa0c4225093a7404720fc0d8b294fc803d444965f0d4",
+        "sha256_in_prefix": "24805c306d3a88dc8274fa0c4225093a7404720fc0d8b294fc803d444965f0d4",
+        "size_in_bytes": 2360
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/bold.xbm",
+        "path_type": "hardlink",
+        "sha256": "cb91ddbcca2dde4df8520a857370efdb5568f544113306de43662e1b814c6a3d",
+        "sha256_in_prefix": "cb91ddbcca2dde4df8520a857370efdb5568f544113306de43662e1b814c6a3d",
+        "size_in_bytes": 290
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/capital.xbm",
+        "path_type": "hardlink",
+        "sha256": "e52e47bbc624e9e9c27acbd652565c2840aa7e53e6c841006dfb2c619d6ed828",
+        "sha256_in_prefix": "e52e47bbc624e9e9c27acbd652565c2840aa7e53e6c841006dfb2c619d6ed828",
+        "size_in_bytes": 299
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/centerj.xbm",
+        "path_type": "hardlink",
+        "sha256": "2b5d6f8592e2bc6f4c4c56947d21e37c91f5f5c3e5795ae408b632d284efa35e",
+        "sha256_in_prefix": "2b5d6f8592e2bc6f4c4c56947d21e37c91f5f5c3e5795ae408b632d284efa35e",
+        "size_in_bytes": 299
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/code.xpm",
+        "path_type": "hardlink",
+        "sha256": "ef34bfc2d0ed60c004ac50237481be5e57932638a7495dc5c8fbe08134a4e29c",
+        "sha256_in_prefix": "ef34bfc2d0ed60c004ac50237481be5e57932638a7495dc5c8fbe08134a4e29c",
+        "size_in_bytes": 642
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/combobox.xbm",
+        "path_type": "hardlink",
+        "sha256": "ca2dc0dab17cf9ae12b98a242d14ecd4f86324c13bd974c48f7bc93903114492",
+        "sha256_in_prefix": "ca2dc0dab17cf9ae12b98a242d14ecd4f86324c13bd974c48f7bc93903114492",
+        "size_in_bytes": 910
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/combobox.xpm",
+        "path_type": "hardlink",
+        "sha256": "7479460890f5e0d184b484b39d34cbdbc423f13c88b59376bff60a441dda9dfc",
+        "sha256_in_prefix": "7479460890f5e0d184b484b39d34cbdbc423f13c88b59376bff60a441dda9dfc",
+        "size_in_bytes": 2367
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/drivea.xbm",
+        "path_type": "hardlink",
+        "sha256": "459e941ecd87984672bf1255da19a8de74f114e173e838f6b85ac734e7ef5fd1",
+        "sha256_in_prefix": "459e941ecd87984672bf1255da19a8de74f114e173e838f6b85ac734e7ef5fd1",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/drivea.xpm",
+        "path_type": "hardlink",
+        "sha256": "05164d5becdda54104b20bc8f7358f627be9f2602d6b3e344a3033d92e73d148",
+        "sha256_in_prefix": "05164d5becdda54104b20bc8f7358f627be9f2602d6b3e344a3033d92e73d148",
+        "size_in_bytes": 1414
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/exit.xpm",
+        "path_type": "hardlink",
+        "sha256": "06b4bec92f4b28afc161359e66a76cf20c32409d98d5b4d2201679bad5fd9300",
+        "sha256_in_prefix": "06b4bec92f4b28afc161359e66a76cf20c32409d98d5b4d2201679bad5fd9300",
+        "size_in_bytes": 2341
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/filebox.xbm",
+        "path_type": "hardlink",
+        "sha256": "3c88d5a7bd7d3715c883fc14f03749cb273bc591a654fa57ee2e857ba6865919",
+        "sha256_in_prefix": "3c88d5a7bd7d3715c883fc14f03749cb273bc591a654fa57ee2e857ba6865919",
+        "size_in_bytes": 907
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/filebox.xpm",
+        "path_type": "hardlink",
+        "sha256": "55f5f55324bda873d0ac1888823f1fd078ba8d7910159026c66540538f0a41a7",
+        "sha256_in_prefix": "55f5f55324bda873d0ac1888823f1fd078ba8d7910159026c66540538f0a41a7",
+        "size_in_bytes": 2359
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/harddisk.xbm",
+        "path_type": "hardlink",
+        "sha256": "459e941ecd87984672bf1255da19a8de74f114e173e838f6b85ac734e7ef5fd1",
+        "sha256_in_prefix": "459e941ecd87984672bf1255da19a8de74f114e173e838f6b85ac734e7ef5fd1",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/harddisk.xpm",
+        "path_type": "hardlink",
+        "sha256": "05164d5becdda54104b20bc8f7358f627be9f2602d6b3e344a3033d92e73d148",
+        "sha256_in_prefix": "05164d5becdda54104b20bc8f7358f627be9f2602d6b3e344a3033d92e73d148",
+        "size_in_bytes": 1414
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/italic.xbm",
+        "path_type": "hardlink",
+        "sha256": "19476ddc404a077fb5d07044453d003fc7043f7cb3e4942525631ce19e129491",
+        "sha256_in_prefix": "19476ddc404a077fb5d07044453d003fc7043f7cb3e4942525631ce19e129491",
+        "size_in_bytes": 296
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/justify.xbm",
+        "path_type": "hardlink",
+        "sha256": "09ef1cec38c60bf480d4a955ca60a67e78b27571025fd7fe9de43650aa22a044",
+        "sha256_in_prefix": "09ef1cec38c60bf480d4a955ca60a67e78b27571025fd7fe9de43650aa22a044",
+        "size_in_bytes": 299
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/leftj.xbm",
+        "path_type": "hardlink",
+        "sha256": "cc37ebc5f953c8dc851960de244de639def70d79065859e908d6444cbe50a6e5",
+        "sha256_in_prefix": "cc37ebc5f953c8dc851960de244de639def70d79065859e908d6444cbe50a6e5",
+        "size_in_bytes": 293
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/netw.xbm",
+        "path_type": "hardlink",
+        "sha256": "9efee21d14731a4d7b3bd7d9e3c02198bca7195173e009c25ef54a7538c93780",
+        "sha256_in_prefix": "9efee21d14731a4d7b3bd7d9e3c02198bca7195173e009c25ef54a7538c93780",
+        "size_in_bytes": 898
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/netw.xpm",
+        "path_type": "hardlink",
+        "sha256": "068e6f025c1e4bb5b019ff51416fcedd4e5d211d5fca99412b19ded1295b2556",
+        "sha256_in_prefix": "068e6f025c1e4bb5b019ff51416fcedd4e5d211d5fca99412b19ded1295b2556",
+        "size_in_bytes": 1431
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/network.xbm",
+        "path_type": "hardlink",
+        "sha256": "9efee21d14731a4d7b3bd7d9e3c02198bca7195173e009c25ef54a7538c93780",
+        "sha256_in_prefix": "9efee21d14731a4d7b3bd7d9e3c02198bca7195173e009c25ef54a7538c93780",
+        "size_in_bytes": 898
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/network.xpm",
+        "path_type": "hardlink",
+        "sha256": "068e6f025c1e4bb5b019ff51416fcedd4e5d211d5fca99412b19ded1295b2556",
+        "sha256_in_prefix": "068e6f025c1e4bb5b019ff51416fcedd4e5d211d5fca99412b19ded1295b2556",
+        "size_in_bytes": 1431
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/optmenu.xpm",
+        "path_type": "hardlink",
+        "sha256": "bad1392a412bdc5b8c9da18bcfb5e92d7623875ffd49e321dd8f322039238302",
+        "sha256_in_prefix": "bad1392a412bdc5b8c9da18bcfb5e92d7623875ffd49e321dd8f322039238302",
+        "size_in_bytes": 2337
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/rightj.xbm",
+        "path_type": "hardlink",
+        "sha256": "58b8d96204593545ee5673cf4d5e09b14c7b922bc95dfd0af7310691cd5e5631",
+        "sha256_in_prefix": "58b8d96204593545ee5673cf4d5e09b14c7b922bc95dfd0af7310691cd5e5631",
+        "size_in_bytes": 296
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/select.xpm",
+        "path_type": "hardlink",
+        "sha256": "b13247f797e9ba8d9ee80b3ad356bf7f24fdad80386a7ab3937dbfd25323ee95",
+        "sha256_in_prefix": "b13247f797e9ba8d9ee80b3ad356bf7f24fdad80386a7ab3937dbfd25323ee95",
+        "size_in_bytes": 2408
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/tix.gif",
+        "path_type": "hardlink",
+        "sha256": "db223d088b0b41ea77614ec7fbfcde1132f68b2e1c3e40c7c1871a541df625ac",
+        "sha256_in_prefix": "db223d088b0b41ea77614ec7fbfcde1132f68b2e1c3e40c7c1871a541df625ac",
+        "size_in_bytes": 11042
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/bitmaps/underlin.xbm",
+        "path_type": "hardlink",
+        "sha256": "4b14b64e1d86de5a5528978f0c5457127b983f41bbbff39caa4a03c1e466b51c",
+        "sha256_in_prefix": "4b14b64e1d86de5a5528978f0c5457127b983f41bbbff39caa4a03c1e466b51c",
+        "size_in_bytes": 305
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/AllSampl.tcl",
+        "path_type": "hardlink",
+        "sha256": "8109f373097ed5de015e9fbfdf6fc8ce38e0f62b04d6ba103584ae773967afbf",
+        "sha256_in_prefix": "8109f373097ed5de015e9fbfdf6fc8ce38e0f62b04d6ba103584ae773967afbf",
+        "size_in_bytes": 5001
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/ArrowBtn.tcl",
+        "path_type": "hardlink",
+        "sha256": "996236d970676ef16c670f7b13aefcd17805bec57abad679c6bff36908bf3061",
+        "sha256_in_prefix": "996236d970676ef16c670f7b13aefcd17805bec57abad679c6bff36908bf3061",
+        "size_in_bytes": 4952
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/Balloon.tcl",
+        "path_type": "hardlink",
+        "sha256": "89b2310e8294fd5cf42d6f8def61a4634090dcc825e4524b34015e56f76ee0d6",
+        "sha256_in_prefix": "89b2310e8294fd5cf42d6f8def61a4634090dcc825e4524b34015e56f76ee0d6",
+        "size_in_bytes": 1769
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/BtnBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "6844a0af067a3c68d1a953cf8cb21cbef2fa9c04985deb4abea643bfd35c1993",
+        "sha256_in_prefix": "6844a0af067a3c68d1a953cf8cb21cbef2fa9c04985deb4abea643bfd35c1993",
+        "size_in_bytes": 2051
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/CObjView.tcl",
+        "path_type": "hardlink",
+        "sha256": "f0816b6a13f3e73dd47f5efb4d8821cfff3a51e5b259dca240f8897546413b08",
+        "sha256_in_prefix": "f0816b6a13f3e73dd47f5efb4d8821cfff3a51e5b259dca240f8897546413b08",
+        "size_in_bytes": 2654
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/ChkList.tcl",
+        "path_type": "hardlink",
+        "sha256": "7f8f6f64db23da5c647e80b9fa3dcee09226d01cc2cb7ae2b9d54065c710599e",
+        "sha256_in_prefix": "7f8f6f64db23da5c647e80b9fa3dcee09226d01cc2cb7ae2b9d54065c710599e",
+        "size_in_bytes": 5487
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/CmpImg.tcl",
+        "path_type": "hardlink",
+        "sha256": "5dc11a3dc49afdb95d7fc693c45d939cab0cda1027a8507dea015fdf5b8cc6a3",
+        "sha256_in_prefix": "5dc11a3dc49afdb95d7fc693c45d939cab0cda1027a8507dea015fdf5b8cc6a3",
+        "size_in_bytes": 2023
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/CmpImg1.tcl",
+        "path_type": "hardlink",
+        "sha256": "aa89dae58d3b9b9a10a162f5b71ad72f3f25f89f464ae516539344603fb75bc3",
+        "sha256_in_prefix": "aa89dae58d3b9b9a10a162f5b71ad72f3f25f89f464ae516539344603fb75bc3",
+        "size_in_bytes": 6163
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/CmpImg2.tcl",
+        "path_type": "hardlink",
+        "sha256": "fcbd3916070c96685686a53ad1d96c71cd318cb4412a589c3339c0e32dabf7a0",
+        "sha256_in_prefix": "fcbd3916070c96685686a53ad1d96c71cd318cb4412a589c3339c0e32dabf7a0",
+        "size_in_bytes": 4649
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/CmpImg3.tcl",
+        "path_type": "hardlink",
+        "sha256": "e7b212552a1894aa206d893d7482db1043f540a0ccf6e75c1149224d750c4f02",
+        "sha256_in_prefix": "e7b212552a1894aa206d893d7482db1043f540a0ccf6e75c1149224d750c4f02",
+        "size_in_bytes": 2621
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/CmpImg4.tcl",
+        "path_type": "hardlink",
+        "sha256": "1e9f30e018befa4975c07c316925a6dd44c12513b33e7728f634a5c9fb47438a",
+        "sha256_in_prefix": "1e9f30e018befa4975c07c316925a6dd44c12513b33e7728f634a5c9fb47438a",
+        "size_in_bytes": 4430
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/ComboBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "41bed1e52e830d86c1cc69c2054e3e4078a17c29aec0f89e217d39a6a3f9ad96",
+        "sha256_in_prefix": "41bed1e52e830d86c1cc69c2054e3e4078a17c29aec0f89e217d39a6a3f9ad96",
+        "size_in_bytes": 3665
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/Control.tcl",
+        "path_type": "hardlink",
+        "sha256": "00603e5e7409dda458d5d11f45fc2e77e71e93ee846b2b1021a429002145dd45",
+        "sha256_in_prefix": "00603e5e7409dda458d5d11f45fc2e77e71e93ee846b2b1021a429002145dd45",
+        "size_in_bytes": 3721
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/DirDlg.tcl",
+        "path_type": "hardlink",
+        "sha256": "771000f308bab1fb8b6878f98d3bb051582c1a28baa0202e9d61730f25036517",
+        "sha256_in_prefix": "771000f308bab1fb8b6878f98d3bb051582c1a28baa0202e9d61730f25036517",
+        "size_in_bytes": 2587
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/DirList.tcl",
+        "path_type": "hardlink",
+        "sha256": "e18eba1750aa57f3a447a43141f9d7b3e96da2a9af8604b1dab7d75959239ae4",
+        "sha256_in_prefix": "e18eba1750aa57f3a447a43141f9d7b3e96da2a9af8604b1dab7d75959239ae4",
+        "size_in_bytes": 2848
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/DirTree.tcl",
+        "path_type": "hardlink",
+        "sha256": "8c1e0d2fe64ce8dd844d812a1aaddd3a509b01d2520dc00a8ae64a0b8d3f9a78",
+        "sha256_in_prefix": "8c1e0d2fe64ce8dd844d812a1aaddd3a509b01d2520dc00a8ae64a0b8d3f9a78",
+        "size_in_bytes": 2825
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/DragDrop.tcl",
+        "path_type": "hardlink",
+        "sha256": "2ca6a4bb39b6de4decabc03077dc2ce035364fd8ed597069246f020ad451cbc8",
+        "sha256_in_prefix": "2ca6a4bb39b6de4decabc03077dc2ce035364fd8ed597069246f020ad451cbc8",
+        "size_in_bytes": 1662
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/DynTree.tcl",
+        "path_type": "hardlink",
+        "sha256": "32e4def921ad1727e7b0cebbf17e0dbcbda2f20e4b5a6271afe4c31dc7acaf17",
+        "sha256_in_prefix": "32e4def921ad1727e7b0cebbf17e0dbcbda2f20e4b5a6271afe4c31dc7acaf17",
+        "size_in_bytes": 3916
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/EFileDlg.tcl",
+        "path_type": "hardlink",
+        "sha256": "976507a1bb4130f3057ceb9abe14d3d8d1df162234f185b1336f9c28323606e9",
+        "sha256_in_prefix": "976507a1bb4130f3057ceb9abe14d3d8d1df162234f185b1336f9c28323606e9",
+        "size_in_bytes": 3226
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/EditGrid.tcl",
+        "path_type": "hardlink",
+        "sha256": "94ff581a620a08c4c5ac9ac16a7efdd6dae05f9d16d9aebdbe3e3f0cad7ea712",
+        "sha256_in_prefix": "94ff581a620a08c4c5ac9ac16a7efdd6dae05f9d16d9aebdbe3e3f0cad7ea712",
+        "size_in_bytes": 7019
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/FileDlg.tcl",
+        "path_type": "hardlink",
+        "sha256": "f92751d5ac23ba3c11d8c5db5ffc48e4853c3dd9452dacfa7340dfead62dfd17",
+        "sha256_in_prefix": "f92751d5ac23ba3c11d8c5db5ffc48e4853c3dd9452dacfa7340dfead62dfd17",
+        "size_in_bytes": 3111
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/FileEnt.tcl",
+        "path_type": "hardlink",
+        "sha256": "a89e7acbf7edb46b8bcd0adc2c7e679d8f0cf586e2190e0131d6dc938087bdd2",
+        "sha256_in_prefix": "a89e7acbf7edb46b8bcd0adc2c7e679d8f0cf586e2190e0131d6dc938087bdd2",
+        "size_in_bytes": 2295
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/HList1.tcl",
+        "path_type": "hardlink",
+        "sha256": "783589db01d682d4cf114562799a93225f44334af8757eb628d32e57955d81ee",
+        "sha256_in_prefix": "783589db01d682d4cf114562799a93225f44334af8757eb628d32e57955d81ee",
+        "size_in_bytes": 4794
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/LabEntry.tcl",
+        "path_type": "hardlink",
+        "sha256": "88899f54110824d56d7fb57f5ecd5b97eaa7984c13e53dcec05d1ba1f3e8b8b7",
+        "sha256_in_prefix": "88899f54110824d56d7fb57f5ecd5b97eaa7984c13e53dcec05d1ba1f3e8b8b7",
+        "size_in_bytes": 2867
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/LabFrame.tcl",
+        "path_type": "hardlink",
+        "sha256": "8441a5c63a17c64dd25f1e0d4ec18f9bbf404b123a3b99028d3d24e4c7729aae",
+        "sha256_in_prefix": "8441a5c63a17c64dd25f1e0d4ec18f9bbf404b123a3b99028d3d24e4c7729aae",
+        "size_in_bytes": 2872
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/ListNBK.tcl",
+        "path_type": "hardlink",
+        "sha256": "c572f3afd878913df6567c94c0fdb5c4257097fc1b93549f8a1302060f04484f",
+        "sha256_in_prefix": "c572f3afd878913df6567c94c0fdb5c4257097fc1b93549f8a1302060f04484f",
+        "size_in_bytes": 3026
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/Meter.tcl",
+        "path_type": "hardlink",
+        "sha256": "80c41b77b7de14ad5a0f6d91f3722912dcbeb5b04fa2fa040f7aab013ea1d12e",
+        "sha256_in_prefix": "80c41b77b7de14ad5a0f6d91f3722912dcbeb5b04fa2fa040f7aab013ea1d12e",
+        "size_in_bytes": 2242
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/NoteBook.tcl",
+        "path_type": "hardlink",
+        "sha256": "26c4d9cfcd0dd1fbce26f84b060da7e785f855910bbb8744abbb8a301505546b",
+        "sha256_in_prefix": "26c4d9cfcd0dd1fbce26f84b060da7e785f855910bbb8744abbb8a301505546b",
+        "size_in_bytes": 3711
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/OptMenu.tcl",
+        "path_type": "hardlink",
+        "sha256": "e9db817c08731f0a67dc7351502ba046bece067e781e910fc2fa0d4094557352",
+        "sha256_in_prefix": "e9db817c08731f0a67dc7351502ba046bece067e781e910fc2fa0d4094557352",
+        "size_in_bytes": 3250
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/PanedWin.tcl",
+        "path_type": "hardlink",
+        "sha256": "009a882ecabc3ada6e381d4d6ef0118bfdb6d1f7fc7bc6d3dbc5baa7fab47651",
+        "sha256_in_prefix": "009a882ecabc3ada6e381d4d6ef0118bfdb6d1f7fc7bc6d3dbc5baa7fab47651",
+        "size_in_bytes": 4335
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/PopMenu.tcl",
+        "path_type": "hardlink",
+        "sha256": "0e9d20c60e5ffcfad32b3dc011cc36071c722ed10188b0732c2c0e7af3e18afa",
+        "sha256_in_prefix": "0e9d20c60e5ffcfad32b3dc011cc36071c722ed10188b0732c2c0e7af3e18afa",
+        "size_in_bytes": 2436
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/SGrid0.tcl",
+        "path_type": "hardlink",
+        "sha256": "988106b37c6e5993693d18a03368d0e1a84b8f95114b1832201c6361ff3c9e1c",
+        "sha256_in_prefix": "988106b37c6e5993693d18a03368d0e1a84b8f95114b1832201c6361ff3c9e1c",
+        "size_in_bytes": 3573
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/SGrid1.tcl",
+        "path_type": "hardlink",
+        "sha256": "cb0388c09b46aeb8828b36e6c3dd804456339731346c4839b2d6e87aba31e6c8",
+        "sha256_in_prefix": "cb0388c09b46aeb8828b36e6c3dd804456339731346c4839b2d6e87aba31e6c8",
+        "size_in_bytes": 5633
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/SHList.tcl",
+        "path_type": "hardlink",
+        "sha256": "5884fea04ec99096d649ad1c7d389d179c05b6cdd5641667270c1e2b73d3990c",
+        "sha256_in_prefix": "5884fea04ec99096d649ad1c7d389d179c05b6cdd5641667270c1e2b73d3990c",
+        "size_in_bytes": 3208
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/SHList2.tcl",
+        "path_type": "hardlink",
+        "sha256": "c4f0a6c494c789b5e5b5f3ce4454b116da9a57b92caae28ea767280e1fd66f55",
+        "sha256_in_prefix": "c4f0a6c494c789b5e5b5f3ce4454b116da9a57b92caae28ea767280e1fd66f55",
+        "size_in_bytes": 5092
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/SListBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "2b2735cbb38b8732aa0c6f21cd551daba46b7f87af90dacdb62ce1e504cb2b8a",
+        "sha256_in_prefix": "2b2735cbb38b8732aa0c6f21cd551daba46b7f87af90dacdb62ce1e504cb2b8a",
+        "size_in_bytes": 2949
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/STList1.tcl",
+        "path_type": "hardlink",
+        "sha256": "95d4ee51467f8b4f8ea2ec1031f122181f12f66a1f408d343c55c4c6b5150f3d",
+        "sha256_in_prefix": "95d4ee51467f8b4f8ea2ec1031f122181f12f66a1f408d343c55c4c6b5150f3d",
+        "size_in_bytes": 1612
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/STList2.tcl",
+        "path_type": "hardlink",
+        "sha256": "a96ed8063a1579c0895b9ae8d93e77de2120d93fe751a4fea58d2babbff1b20b",
+        "sha256_in_prefix": "a96ed8063a1579c0895b9ae8d93e77de2120d93fe751a4fea58d2babbff1b20b",
+        "size_in_bytes": 2473
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/STList3.tcl",
+        "path_type": "hardlink",
+        "sha256": "b7f04fc61aaa7167bf7c1aa8be5ba59556015e30b084f1eab9a5f040ac4d9d3a",
+        "sha256_in_prefix": "b7f04fc61aaa7167bf7c1aa8be5ba59556015e30b084f1eab9a5f040ac4d9d3a",
+        "size_in_bytes": 3090
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/SText.tcl",
+        "path_type": "hardlink",
+        "sha256": "215b50d920b10740acc10ddf4f6ebfe5123ef8806d5099c1906d424cdaca0525",
+        "sha256_in_prefix": "215b50d920b10740acc10ddf4f6ebfe5123ef8806d5099c1906d424cdaca0525",
+        "size_in_bytes": 2617
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/SWindow.tcl",
+        "path_type": "hardlink",
+        "sha256": "63bbfc5cb9977fe801da0fd33352027c13def4ce851ea7f4b2255fbea36ef5a5",
+        "sha256_in_prefix": "63bbfc5cb9977fe801da0fd33352027c13def4ce851ea7f4b2255fbea36ef5a5",
+        "size_in_bytes": 2807
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/Sample.tcl",
+        "path_type": "hardlink",
+        "sha256": "e4c09fafc512d7c43674534cc52c8c08b9e6dfb023a39416ab723cb339be9ac1",
+        "sha256_in_prefix": "e4c09fafc512d7c43674534cc52c8c08b9e6dfb023a39416ab723cb339be9ac1",
+        "size_in_bytes": 1065
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/Select.tcl",
+        "path_type": "hardlink",
+        "sha256": "047a63479cec283e73987346cb9af9dd0157f39afb4669509c5bf7ebbc1d16de",
+        "sha256_in_prefix": "047a63479cec283e73987346cb9af9dd0157f39afb4669509c5bf7ebbc1d16de",
+        "size_in_bytes": 3433
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/StdBBox.tcl",
+        "path_type": "hardlink",
+        "sha256": "df32e7616d982d73278fba4e418e9fd78777caeff9c08a0e8c1b86b3962e8910",
+        "sha256_in_prefix": "df32e7616d982d73278fba4e418e9fd78777caeff9c08a0e8c1b86b3962e8910",
+        "size_in_bytes": 2351
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/Tree.tcl",
+        "path_type": "hardlink",
+        "sha256": "22396dd36fbdab8ea59ee5a8de697398a63a86a1763cea84b9d7f9d5405d5407",
+        "sha256_in_prefix": "22396dd36fbdab8ea59ee5a8de697398a63a86a1763cea84b9d7f9d5405d5407",
+        "size_in_bytes": 2744
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/Xpm.tcl",
+        "path_type": "hardlink",
+        "sha256": "a5cd5eed2739fcd01d7f2f5942c65f8e3d3deff281c4a8e8fbba80df37e379ba",
+        "sha256_in_prefix": "a5cd5eed2739fcd01d7f2f5942c65f8e3d3deff281c4a8e8fbba80df37e379ba",
+        "size_in_bytes": 3009
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/samples/Xpm1.tcl",
+        "path_type": "hardlink",
+        "sha256": "74634645297a240d0c216d6455c2fe918af2857a1f0975a3ff0b11b6f1633193",
+        "sha256_in_prefix": "74634645297a240d0c216d6455c2fe918af2857a1f0975a3ff0b11b6f1633193",
+        "size_in_bytes": 3557
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/tclIndex",
+        "path_type": "hardlink",
+        "sha256": "d94e63965733460544427beb671228ed11123ffa51ae8d1d28fb04ad2b81f88b",
+        "sha256_in_prefix": "d94e63965733460544427beb671228ed11123ffa51ae8d1d28fb04ad2b81f88b",
+        "size_in_bytes": 3897
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/tixwidgets.tcl",
+        "path_type": "hardlink",
+        "sha256": "a4c9022069cf000a5ee4a77dc537acb107fdff1d3672f7b044870983fb6327b2",
+        "sha256_in_prefix": "a4c9022069cf000a5ee4a77dc537acb107fdff1d3672f7b044870983fb6327b2",
+        "size_in_bytes": 9356
+      },
+      {
+        "_path": "tcl/tix8.4.3/demos/widget",
+        "path_type": "hardlink",
+        "sha256": "82fc32fc51612270de8d70cc14a20ab2428f50a782df707d2aca1083f0455f91",
+        "sha256_in_prefix": "82fc32fc51612270de8d70cc14a20ab2428f50a782df707d2aca1083f0455f91",
+        "size_in_bytes": 13761
+      },
+      {
+        "_path": "tcl/tix8.4.3/fs.tcl",
+        "path_type": "hardlink",
+        "sha256": "f6283544be918381872d3b483d6ef1fe240a6dcd45ab013a28eb9866644a08f1",
+        "sha256_in_prefix": "f6283544be918381872d3b483d6ef1fe240a6dcd45ab013a28eb9866644a08f1",
+        "size_in_bytes": 4165
+      },
+      {
+        "_path": "tcl/tix8.4.3/pkgIndex.tcl",
+        "path_type": "hardlink",
+        "sha256": "64c64e7b58a13810daff8fc3aca3aa26d790269a6c9f54e161c2fb987a30e5f2",
+        "sha256_in_prefix": "64c64e7b58a13810daff8fc3aca3aa26d790269a6c9f54e161c2fb987a30e5f2",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/10Point.fs",
+        "path_type": "hardlink",
+        "sha256": "5ae702df92cedd70cddc9ef51f756bde17e23f1c5cf6a5d3fc2b9559e05b26fe",
+        "sha256_in_prefix": "5ae702df92cedd70cddc9ef51f756bde17e23f1c5cf6a5d3fc2b9559e05b26fe",
+        "size_in_bytes": 664
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/10Point.fsc",
+        "path_type": "hardlink",
+        "sha256": "c0d99286eae3e39f121acb971830813298b7f98b01e1341f362302c1378a4d83",
+        "sha256_in_prefix": "c0d99286eae3e39f121acb971830813298b7f98b01e1341f362302c1378a4d83",
+        "size_in_bytes": 2090
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/12Point.fs",
+        "path_type": "hardlink",
+        "sha256": "73696fdf63c9c8cd83624ee3a1e95d18688db9c8f5b2fba767e9abac5b321e55",
+        "sha256_in_prefix": "73696fdf63c9c8cd83624ee3a1e95d18688db9c8f5b2fba767e9abac5b321e55",
+        "size_in_bytes": 663
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/12Point.fsc",
+        "path_type": "hardlink",
+        "sha256": "3241edc24ad328801ca6f65db7f7566cfaf17a38a3be907b5620d9d9fa885aee",
+        "sha256_in_prefix": "3241edc24ad328801ca6f65db7f7566cfaf17a38a3be907b5620d9d9fa885aee",
+        "size_in_bytes": 2089
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/14Point.fs",
+        "path_type": "hardlink",
+        "sha256": "8820f5ec1f4a756235f227ac00e524e0b974341f0f796fc2b269a8f6a832cfec",
+        "sha256_in_prefix": "8820f5ec1f4a756235f227ac00e524e0b974341f0f796fc2b269a8f6a832cfec",
+        "size_in_bytes": 661
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/14Point.fsc",
+        "path_type": "hardlink",
+        "sha256": "718ff155cbdeb67468939b93a9efdba9585f526d40526b80d4dde98ef7254c6b",
+        "sha256_in_prefix": "718ff155cbdeb67468939b93a9efdba9585f526d40526b80d4dde98ef7254c6b",
+        "size_in_bytes": 2155
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/Bisque.cs",
+        "path_type": "hardlink",
+        "sha256": "25a34d43afdff0dbb6ef04308ac0b97cc89343e4ee065ecb61c7d3369b83c589",
+        "sha256_in_prefix": "25a34d43afdff0dbb6ef04308ac0b97cc89343e4ee065ecb61c7d3369b83c589",
+        "size_in_bytes": 1063
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/Bisque.csc",
+        "path_type": "hardlink",
+        "sha256": "3ba01c10024b474c2f6b61a6d54c92fd9f95ec4c03a2f3ae6cb806a401004ac0",
+        "sha256_in_prefix": "3ba01c10024b474c2f6b61a6d54c92fd9f95ec4c03a2f3ae6cb806a401004ac0",
+        "size_in_bytes": 22877
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/Blue.cs",
+        "path_type": "hardlink",
+        "sha256": "38dc4760292c2c3182b893e48cdc028502bf97e8d12b8f62596f8296d6526595",
+        "sha256_in_prefix": "38dc4760292c2c3182b893e48cdc028502bf97e8d12b8f62596f8296d6526595",
+        "size_in_bytes": 1080
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/Blue.csc",
+        "path_type": "hardlink",
+        "sha256": "209c569c02c014a3ad40faad4603d8248c9aa457339bea9eea0fd83850717d64",
+        "sha256_in_prefix": "209c569c02c014a3ad40faad4603d8248c9aa457339bea9eea0fd83850717d64",
+        "size_in_bytes": 22890
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/Gray.cs",
+        "path_type": "hardlink",
+        "sha256": "192dfa09f01124f8eec3e46e2ba26bf5291f91b723c2515645dfb3c10859b307",
+        "sha256_in_prefix": "192dfa09f01124f8eec3e46e2ba26bf5291f91b723c2515645dfb3c10859b307",
+        "size_in_bytes": 1081
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/Gray.csc",
+        "path_type": "hardlink",
+        "sha256": "86bce61b378d6ee3bbc306ad40ada70f46c528966b3b3f28df7d0d702d26f04f",
+        "sha256_in_prefix": "86bce61b378d6ee3bbc306ad40ada70f46c528966b3b3f28df7d0d702d26f04f",
+        "size_in_bytes": 22891
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/Makefile",
+        "path_type": "hardlink",
+        "sha256": "830a896c087a5d6dd7ece2396fa8eb7424b80f7de1e4b7747b87798139f58848",
+        "sha256_in_prefix": "830a896c087a5d6dd7ece2396fa8eb7424b80f7de1e4b7747b87798139f58848",
+        "size_in_bytes": 882
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/Old12Pt.fs",
+        "path_type": "hardlink",
+        "sha256": "06c0685af83fcb93d8e9c9fe05b3b87e6ff97bfd07bc22b68858eb66f3df1d24",
+        "sha256_in_prefix": "06c0685af83fcb93d8e9c9fe05b3b87e6ff97bfd07bc22b68858eb66f3df1d24",
+        "size_in_bytes": 555
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/Old14Pt.fs",
+        "path_type": "hardlink",
+        "sha256": "27c79803b703e84d2c228dd365b52eeb66c2ae95ed21a5419dcb476b5b029ecf",
+        "sha256_in_prefix": "27c79803b703e84d2c228dd365b52eeb66c2ae95ed21a5419dcb476b5b029ecf",
+        "size_in_bytes": 512
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/SGIGray.cs",
+        "path_type": "hardlink",
+        "sha256": "d875f29b4a7c0e462396c40bb9b5b2798d777d53e3dc51280c11222ff5b40e25",
+        "sha256_in_prefix": "d875f29b4a7c0e462396c40bb9b5b2798d777d53e3dc51280c11222ff5b40e25",
+        "size_in_bytes": 1064
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/SGIGray.csc",
+        "path_type": "hardlink",
+        "sha256": "feb596c01617784556b7e11d3fb29f0f6453d4da3a46e60405109f90e9f4e573",
+        "sha256_in_prefix": "feb596c01617784556b7e11d3fb29f0f6453d4da3a46e60405109f90e9f4e573",
+        "size_in_bytes": 22876
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TK.cs",
+        "path_type": "hardlink",
+        "sha256": "776ae50d94a64df358ae46d8fa8c5eb493fdc664696167548a0311d0e897c6e9",
+        "sha256_in_prefix": "776ae50d94a64df358ae46d8fa8c5eb493fdc664696167548a0311d0e897c6e9",
+        "size_in_bytes": 1059
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TK.csc",
+        "path_type": "hardlink",
+        "sha256": "85b07443a34f2d04c6603654f2d0b7637c7ec4b2394cc025114804b47bfc205c",
+        "sha256_in_prefix": "85b07443a34f2d04c6603654f2d0b7637c7ec4b2394cc025114804b47bfc205c",
+        "size_in_bytes": 2095
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TK.fs",
+        "path_type": "hardlink",
+        "sha256": "59a38ddde6ab3349dae5a81f4e5c889e99a8752336fe5599ff0a385c71fa129b",
+        "sha256_in_prefix": "59a38ddde6ab3349dae5a81f4e5c889e99a8752336fe5599ff0a385c71fa129b",
+        "size_in_bytes": 522
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TK.fsc",
+        "path_type": "hardlink",
+        "sha256": "8d60dbd699430f60471971f7431e2ae769a46da938dbfe79765375a30ce2f176",
+        "sha256_in_prefix": "8d60dbd699430f60471971f7431e2ae769a46da938dbfe79765375a30ce2f176",
+        "size_in_bytes": 588
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TixGray.cs",
+        "path_type": "hardlink",
+        "sha256": "ba5807e0ab2867b6e31fb2539b61c4f1253474a07767dced095c806e61d2aa4c",
+        "sha256_in_prefix": "ba5807e0ab2867b6e31fb2539b61c4f1253474a07767dced095c806e61d2aa4c",
+        "size_in_bytes": 1062
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TixGray.csc",
+        "path_type": "hardlink",
+        "sha256": "4805333c38118a33b9f7918601fbf23b66ead7280a21f962165eaf8e788e32d0",
+        "sha256_in_prefix": "4805333c38118a33b9f7918601fbf23b66ead7280a21f962165eaf8e788e32d0",
+        "size_in_bytes": 22878
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TkWin.cs",
+        "path_type": "hardlink",
+        "sha256": "153f6332172525be0ee58a80bf8515d400d0d829078caa3e1fe3bdb7f6b5c389",
+        "sha256_in_prefix": "153f6332172525be0ee58a80bf8515d400d0d829078caa3e1fe3bdb7f6b5c389",
+        "size_in_bytes": 2314
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TkWin.csc",
+        "path_type": "hardlink",
+        "sha256": "88edda70c62895ad58df9bb8f2af3e8246c134269eeb9855ab1d70ea7b7b92b0",
+        "sha256_in_prefix": "88edda70c62895ad58df9bb8f2af3e8246c134269eeb9855ab1d70ea7b7b92b0",
+        "size_in_bytes": 22635
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TkWin.fs",
+        "path_type": "hardlink",
+        "sha256": "b51bf585a338ab96bff080855182a5e29330ee2cf7716463914f017fa7ac02ba",
+        "sha256_in_prefix": "b51bf585a338ab96bff080855182a5e29330ee2cf7716463914f017fa7ac02ba",
+        "size_in_bytes": 406
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/TkWin.fsc",
+        "path_type": "hardlink",
+        "sha256": "9fe061aa39e450768c58e77aa39b0ea9c980e60d8f9505afa9934d5439b6758a",
+        "sha256_in_prefix": "9fe061aa39e450768c58e77aa39b0ea9c980e60d8f9505afa9934d5439b6758a",
+        "size_in_bytes": 1708
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/WmDefault.cs",
+        "path_type": "hardlink",
+        "sha256": "638882f34bb3caeef3f0f1bd4997a123de116af0b16289e62a537e4e63f6827a",
+        "sha256_in_prefix": "638882f34bb3caeef3f0f1bd4997a123de116af0b16289e62a537e4e63f6827a",
+        "size_in_bytes": 1497
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/WmDefault.csc",
+        "path_type": "hardlink",
+        "sha256": "f32a52bacaf45cee173d6d4982a39a9734ba510db15f081d5cb6a9f2ff955700",
+        "sha256_in_prefix": "f32a52bacaf45cee173d6d4982a39a9734ba510db15f081d5cb6a9f2ff955700",
+        "size_in_bytes": 14882
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/WmDefault.fs",
+        "path_type": "hardlink",
+        "sha256": "3c95d51b28cdf09c97990e6ba11b1f3e294419ed678771e2054115e7fb002bb4",
+        "sha256_in_prefix": "3c95d51b28cdf09c97990e6ba11b1f3e294419ed678771e2054115e7fb002bb4",
+        "size_in_bytes": 778
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/WmDefault.fsc",
+        "path_type": "hardlink",
+        "sha256": "77722943e8b234fdaba9b85206a3188913fc1d423faf45cbff87d3164ee63e52",
+        "sha256_in_prefix": "77722943e8b234fdaba9b85206a3188913fc1d423faf45cbff87d3164ee63e52",
+        "size_in_bytes": 2241
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/WmDefault.py",
+        "path_type": "hardlink",
+        "sha256": "3a639975edd8a50c6d9ad0dc1fd50c2cb9213f1f8d2879ba661c6a9ce78b3dd3",
+        "sha256_in_prefix": "3a639975edd8a50c6d9ad0dc1fd50c2cb9213f1f8d2879ba661c6a9ce78b3dd3",
+        "size_in_bytes": 3597
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/WmDefault.tcl",
+        "path_type": "hardlink",
+        "sha256": "186de6b0a494b36ae97ba9237f9ffa03f38f670e855ba0e72bf0ef192e52ebe4",
+        "sha256_in_prefix": "186de6b0a494b36ae97ba9237f9ffa03f38f670e855ba0e72bf0ef192e52ebe4",
+        "size_in_bytes": 34898
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/WmDefault.txt",
+        "path_type": "hardlink",
+        "sha256": "1800c8ec457feaef748762c8059251e5c8f160f004b7a83e1f9a50da5b68e6b3",
+        "sha256_in_prefix": "1800c8ec457feaef748762c8059251e5c8f160f004b7a83e1f9a50da5b68e6b3",
+        "size_in_bytes": 4466
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/pkgIndex.tcl",
+        "path_type": "hardlink",
+        "sha256": "1c9e2e43331a73b84fee2a7be29eda696ddb650412ba62a11ef97ba53b021a64",
+        "sha256_in_prefix": "1c9e2e43331a73b84fee2a7be29eda696ddb650412ba62a11ef97ba53b021a64",
+        "size_in_bytes": 271
+      },
+      {
+        "_path": "tcl/tix8.4.3/pref/tixmkpref",
+        "path_type": "hardlink",
+        "sha256": "9c87861571ba882cecabb5a00cb771b3ed3cd2dd87851c2bc26c9a05abba6ed1",
+        "sha256_in_prefix": "9c87861571ba882cecabb5a00cb771b3ed3cd2dd87851c2bc26c9a05abba6ed1",
+        "size_in_bytes": 10032
+      },
+      {
+        "_path": "tcl/tix8.4.3/tix84.dll",
+        "path_type": "hardlink",
+        "sha256": "43460547dd1555aa976fa57fd2b73d48bb8a5e104d71843d9a83e300c754304e",
+        "sha256_in_prefix": "43460547dd1555aa976fa57fd2b73d48bb8a5e104d71843d9a83e300c754304e",
+        "size_in_bytes": 382736
+      },
+      {
+        "_path": "tcl/tix8.4.3/tix84.lib",
+        "path_type": "hardlink",
+        "sha256": "c538f53e9b662201e7ba7d29295b0e5e24feab94d0982570507fdf6fa7506154",
+        "sha256_in_prefix": "c538f53e9b662201e7ba7d29295b0e5e24feab94d0982570507fdf6fa7506154",
+        "size_in_bytes": 34156
+      },
+      {
+        "_path": "tcl/tk8.6/bgerror.tcl",
+        "path_type": "hardlink",
+        "sha256": "8822365ee279bebf7a36cfdedba1114762f894781f4635170cc5d85ff5b17923",
+        "sha256_in_prefix": "8822365ee279bebf7a36cfdedba1114762f894781f4635170cc5d85ff5b17923",
+        "size_in_bytes": 8806
+      },
+      {
+        "_path": "tcl/tk8.6/button.tcl",
+        "path_type": "hardlink",
+        "sha256": "1f5dd8d81b26f16e772e92fd2a22accb785004d0ed3447e54f87005d9c6a07a5",
+        "sha256_in_prefix": "1f5dd8d81b26f16e772e92fd2a22accb785004d0ed3447e54f87005d9c6a07a5",
+        "size_in_bytes": 21612
+      },
+      {
+        "_path": "tcl/tk8.6/choosedir.tcl",
+        "path_type": "hardlink",
+        "sha256": "35b208e8570b0d1e0ca1c911d4fe02ee3b0cfe5667cf1bdec006cf9d043122ba",
+        "sha256_in_prefix": "35b208e8570b0d1e0ca1c911d4fe02ee3b0cfe5667cf1bdec006cf9d043122ba",
+        "size_in_bytes": 9960
+      },
+      {
+        "_path": "tcl/tk8.6/clrpick.tcl",
+        "path_type": "hardlink",
+        "sha256": "e7aa73828a731dcc9541308aa53ff3cf550a0952fd42c4d86d831f87fb47cdcf",
+        "sha256_in_prefix": "e7aa73828a731dcc9541308aa53ff3cf550a0952fd42c4d86d831f87fb47cdcf",
+        "size_in_bytes": 22112
+      },
+      {
+        "_path": "tcl/tk8.6/comdlg.tcl",
+        "path_type": "hardlink",
+        "sha256": "c7da292ccf5f413e599c3491c331ffd58cf273f8477facb097e6f36cf1f32a08",
+        "sha256_in_prefix": "c7da292ccf5f413e599c3491c331ffd58cf273f8477facb097e6f36cf1f32a08",
+        "size_in_bytes": 8690
+      },
+      {
+        "_path": "tcl/tk8.6/console.tcl",
+        "path_type": "hardlink",
+        "sha256": "9d023dbf3b0fcd25e13502b34f8be63f64da592fa612ebd31c08af4ac27338d6",
+        "sha256_in_prefix": "9d023dbf3b0fcd25e13502b34f8be63f64da592fa612ebd31c08af4ac27338d6",
+        "size_in_bytes": 33942
+      },
+      {
+        "_path": "tcl/tk8.6/demos/README",
+        "path_type": "hardlink",
+        "sha256": "ba3178afafccb3ccccbd9b0bfa311973bd79c1d143f2ea14a3af1c6a82f7ccec",
+        "sha256_in_prefix": "ba3178afafccb3ccccbd9b0bfa311973bd79c1d143f2ea14a3af1c6a82f7ccec",
+        "size_in_bytes": 2126
+      },
+      {
+        "_path": "tcl/tk8.6/demos/anilabel.tcl",
+        "path_type": "hardlink",
+        "sha256": "15f62112d522570d1bd80aef38ebd292c3886d0e975f883c1f6ec4dcd315c07a",
+        "sha256_in_prefix": "15f62112d522570d1bd80aef38ebd292c3886d0e975f883c1f6ec4dcd315c07a",
+        "size_in_bytes": 6830
+      },
+      {
+        "_path": "tcl/tk8.6/demos/aniwave.tcl",
+        "path_type": "hardlink",
+        "sha256": "c4f59254d921b440bb3f6b6cc6fa1b2d24f9d8547a286b98285ec4f0c45702c9",
+        "sha256_in_prefix": "c4f59254d921b440bb3f6b6cc6fa1b2d24f9d8547a286b98285ec4f0c45702c9",
+        "size_in_bytes": 3598
+      },
+      {
+        "_path": "tcl/tk8.6/demos/arrow.tcl",
+        "path_type": "hardlink",
+        "sha256": "818bd1a13b4afc9ab897da219cfc174c477d1aa55f9db5da005d4e5ae1a03806",
+        "sha256_in_prefix": "818bd1a13b4afc9ab897da219cfc174c477d1aa55f9db5da005d4e5ae1a03806",
+        "size_in_bytes": 8351
+      },
+      {
+        "_path": "tcl/tk8.6/demos/bind.tcl",
+        "path_type": "hardlink",
+        "sha256": "941ee3f0080d24d6942160813acf9bacab5c52f082756023cd05e3ea28e71b02",
+        "sha256_in_prefix": "941ee3f0080d24d6942160813acf9bacab5c52f082756023cd05e3ea28e71b02",
+        "size_in_bytes": 3156
+      },
+      {
+        "_path": "tcl/tk8.6/demos/bitmap.tcl",
+        "path_type": "hardlink",
+        "sha256": "b6c1f7b01f04b7880616e2affe948fc4645bae51a1df7f51e545e0896845f8fe",
+        "sha256_in_prefix": "b6c1f7b01f04b7880616e2affe948fc4645bae51a1df7f51e545e0896845f8fe",
+        "size_in_bytes": 1463
+      },
+      {
+        "_path": "tcl/tk8.6/demos/browse",
+        "path_type": "hardlink",
+        "sha256": "d5a6843453fa7beec0589e07351799708b27ca0d3fef640190de01344259f11d",
+        "sha256_in_prefix": "d5a6843453fa7beec0589e07351799708b27ca0d3fef640190de01344259f11d",
+        "size_in_bytes": 1821
+      },
+      {
+        "_path": "tcl/tk8.6/demos/button.tcl",
+        "path_type": "hardlink",
+        "sha256": "6ff1e752e51d72d8079b499865afd3c3cb9f4c4fd69e48c0e5ec5d701aa6a1d5",
+        "sha256_in_prefix": "6ff1e752e51d72d8079b499865afd3c3cb9f4c4fd69e48c0e5ec5d701aa6a1d5",
+        "size_in_bytes": 1551
+      },
+      {
+        "_path": "tcl/tk8.6/demos/check.tcl",
+        "path_type": "hardlink",
+        "sha256": "a5b535512fe3c68183faaa55fb1029b7de651bec1fd0e7f50064d8d73e080ffd",
+        "sha256_in_prefix": "a5b535512fe3c68183faaa55fb1029b7de651bec1fd0e7f50064d8d73e080ffd",
+        "size_in_bytes": 2349
+      },
+      {
+        "_path": "tcl/tk8.6/demos/clrpick.tcl",
+        "path_type": "hardlink",
+        "sha256": "7e7fd178c20f07b96ff51cb375e6ad422807d026a0c5b57deb5e5acad2661783",
+        "sha256_in_prefix": "7e7fd178c20f07b96ff51cb375e6ad422807d026a0c5b57deb5e5acad2661783",
+        "size_in_bytes": 1485
+      },
+      {
+        "_path": "tcl/tk8.6/demos/colors.tcl",
+        "path_type": "hardlink",
+        "sha256": "fde271dc94cc6d81ec874188e80fcdd8854a40fb1c45f6ecbfb9cce8991a7d3c",
+        "sha256_in_prefix": "fde271dc94cc6d81ec874188e80fcdd8854a40fb1c45f6ecbfb9cce8991a7d3c",
+        "size_in_bytes": 5101
+      },
+      {
+        "_path": "tcl/tk8.6/demos/combo.tcl",
+        "path_type": "hardlink",
+        "sha256": "85ba1d5d4265cc2949b011a0ca7823e600d0dfa38b5155876e892c125499a8e2",
+        "sha256_in_prefix": "85ba1d5d4265cc2949b011a0ca7823e600d0dfa38b5155876e892c125499a8e2",
+        "size_in_bytes": 2024
+      },
+      {
+        "_path": "tcl/tk8.6/demos/cscroll.tcl",
+        "path_type": "hardlink",
+        "sha256": "93c15445de222a3afd54414d1564e4052b08b413aa1c39b70688c85cda63e30b",
+        "sha256_in_prefix": "93c15445de222a3afd54414d1564e4052b08b413aa1c39b70688c85cda63e30b",
+        "size_in_bytes": 5208
+      },
+      {
+        "_path": "tcl/tk8.6/demos/ctext.tcl",
+        "path_type": "hardlink",
+        "sha256": "6f7dac4ff555c9ccaabeef89a17f234dc4b5ca818848b99089fe42d5da4704ee",
+        "sha256_in_prefix": "6f7dac4ff555c9ccaabeef89a17f234dc4b5ca818848b99089fe42d5da4704ee",
+        "size_in_bytes": 6381
+      },
+      {
+        "_path": "tcl/tk8.6/demos/dialog1.tcl",
+        "path_type": "hardlink",
+        "sha256": "61c48d3c23d6a2a3c0c5229ae9838884f77fa7c2514f53634791210f3a13a97f",
+        "sha256_in_prefix": "61c48d3c23d6a2a3c0c5229ae9838884f77fa7c2514f53634791210f3a13a97f",
+        "size_in_bytes": 999
+      },
+      {
+        "_path": "tcl/tk8.6/demos/dialog2.tcl",
+        "path_type": "hardlink",
+        "sha256": "247082a303e8d699011d6126361a842dcf53164ae9699d2fda0492d691d96c53",
+        "sha256_in_prefix": "247082a303e8d699011d6126361a842dcf53164ae9699d2fda0492d691d96c53",
+        "size_in_bytes": 846
+      },
+      {
+        "_path": "tcl/tk8.6/demos/en.msg",
+        "path_type": "hardlink",
+        "sha256": "3b3d80f5e884a94c27a97fd46ddf2947feedc7c960bbfa359bdea6ddd1e0df87",
+        "sha256_in_prefix": "3b3d80f5e884a94c27a97fd46ddf2947feedc7c960bbfa359bdea6ddd1e0df87",
+        "size_in_bytes": 3964
+      },
+      {
+        "_path": "tcl/tk8.6/demos/entry1.tcl",
+        "path_type": "hardlink",
+        "sha256": "9675cae23d2481e8edd23b6393cd1bba39815858ac4ddb2a73358eb0c2d1ec8a",
+        "sha256_in_prefix": "9675cae23d2481e8edd23b6393cd1bba39815858ac4ddb2a73358eb0c2d1ec8a",
+        "size_in_bytes": 1435
+      },
+      {
+        "_path": "tcl/tk8.6/demos/entry2.tcl",
+        "path_type": "hardlink",
+        "sha256": "cf8be7001f870ee5d5279337483368dcfe9d5e52022f29523cf13e185744af89",
+        "sha256_in_prefix": "cf8be7001f870ee5d5279337483368dcfe9d5e52022f29523cf13e185744af89",
+        "size_in_bytes": 2137
+      },
+      {
+        "_path": "tcl/tk8.6/demos/entry3.tcl",
+        "path_type": "hardlink",
+        "sha256": "251b02601ca72e97378201085cef6a1a174ba1e16b60e735b508dd37f51f0f0e",
+        "sha256_in_prefix": "251b02601ca72e97378201085cef6a1a174ba1e16b60e735b508dd37f51f0f0e",
+        "size_in_bytes": 6287
+      },
+      {
+        "_path": "tcl/tk8.6/demos/filebox.tcl",
+        "path_type": "hardlink",
+        "sha256": "277669c033ffe1450f762892e31f9ded824776e5e70d6132eeb167fd15533f9b",
+        "sha256_in_prefix": "277669c033ffe1450f762892e31f9ded824776e5e70d6132eeb167fd15533f9b",
+        "size_in_bytes": 2432
+      },
+      {
+        "_path": "tcl/tk8.6/demos/floor.tcl",
+        "path_type": "hardlink",
+        "sha256": "fc7e5d5fc0e84cfe7b9b1875b401bd471ea0a9773f1e8d06a92e67cb1edde61f",
+        "sha256_in_prefix": "fc7e5d5fc0e84cfe7b9b1875b401bd471ea0a9773f1e8d06a92e67cb1edde61f",
+        "size_in_bytes": 81174
+      },
+      {
+        "_path": "tcl/tk8.6/demos/fontchoose.tcl",
+        "path_type": "hardlink",
+        "sha256": "9bf3d1f798589c269ecfd2b76dde820fff0be027e42c34d4bb13a6b78a5c4f05",
+        "sha256_in_prefix": "9bf3d1f798589c269ecfd2b76dde820fff0be027e42c34d4bb13a6b78a5c4f05",
+        "size_in_bytes": 1777
+      },
+      {
+        "_path": "tcl/tk8.6/demos/form.tcl",
+        "path_type": "hardlink",
+        "sha256": "9b1de253d0bd2e679a4759f2c9c486105813c95a7f55696914d6c8874e91c6a1",
+        "sha256_in_prefix": "9b1de253d0bd2e679a4759f2c9c486105813c95a7f55696914d6c8874e91c6a1",
+        "size_in_bytes": 1084
+      },
+      {
+        "_path": "tcl/tk8.6/demos/goldberg.tcl",
+        "path_type": "hardlink",
+        "sha256": "0b1bb7e4a679199610dc99863c0a4aef59cb8cf2b3d3a5cd97cf567ec9cc1026",
+        "sha256_in_prefix": "0b1bb7e4a679199610dc99863c0a4aef59cb8cf2b3d3a5cd97cf567ec9cc1026",
+        "size_in_bytes": 58431
+      },
+      {
+        "_path": "tcl/tk8.6/demos/hello",
+        "path_type": "hardlink",
+        "sha256": "741bbaf0dc065eb4fcc7b655e0f830bce6c9d9c22cf61ac9f18c17986819f414",
+        "sha256_in_prefix": "741bbaf0dc065eb4fcc7b655e0f830bce6c9d9c22cf61ac9f18c17986819f414",
+        "size_in_bytes": 531
+      },
+      {
+        "_path": "tcl/tk8.6/demos/hscale.tcl",
+        "path_type": "hardlink",
+        "sha256": "0ab4ebc5f7af945bcb81aabbf0f7839d88d3347c0f1988e2a6366eee090564f5",
+        "sha256_in_prefix": "0ab4ebc5f7af945bcb81aabbf0f7839d88d3347c0f1988e2a6366eee090564f5",
+        "size_in_bytes": 1542
+      },
+      {
+        "_path": "tcl/tk8.6/demos/icon.tcl",
+        "path_type": "hardlink",
+        "sha256": "f8818b41f8661ac17db45d622855909865b8a5cb210fc1b22f3375f3511ed47c",
+        "sha256_in_prefix": "f8818b41f8661ac17db45d622855909865b8a5cb210fc1b22f3375f3511ed47c",
+        "size_in_bytes": 2114
+      },
+      {
+        "_path": "tcl/tk8.6/demos/image1.tcl",
+        "path_type": "hardlink",
+        "sha256": "fcc89527b6027b143da4449d13baad8eb1604a7b86d4824a865465ef6f40ac3b",
+        "sha256_in_prefix": "fcc89527b6027b143da4449d13baad8eb1604a7b86d4824a865465ef6f40ac3b",
+        "size_in_bytes": 1037
+      },
+      {
+        "_path": "tcl/tk8.6/demos/image2.tcl",
+        "path_type": "hardlink",
+        "sha256": "8e60cec6bbaf17048bc2c1b6b147d2c85a7014b744eb7f7efe533d9ef3932d58",
+        "sha256_in_prefix": "8e60cec6bbaf17048bc2c1b6b147d2c85a7014b744eb7f7efe533d9ef3932d58",
+        "size_in_bytes": 3467
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/earth.gif",
+        "path_type": "hardlink",
+        "sha256": "88af7ae24fd08d5eb144e938a4381d28638bc50d15c8e5f3e30ca73b0fba961f",
+        "sha256_in_prefix": "88af7ae24fd08d5eb144e938a4381d28638bc50d15c8e5f3e30ca73b0fba961f",
+        "size_in_bytes": 51712
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/earthmenu.png",
+        "path_type": "hardlink",
+        "sha256": "9bf8d96016039d7fdb2ffc506743724636a70ed5925199aab64ca20820963bde",
+        "sha256_in_prefix": "9bf8d96016039d7fdb2ffc506743724636a70ed5925199aab64ca20820963bde",
+        "size_in_bytes": 8157
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/earthris.gif",
+        "path_type": "hardlink",
+        "sha256": "c2da473e55d8317bd1f983638adb729bff1461de590d76f99d8b3430c71e0f6e",
+        "sha256_in_prefix": "c2da473e55d8317bd1f983638adb729bff1461de590d76f99d8b3430c71e0f6e",
+        "size_in_bytes": 6343
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/flagdown.xbm",
+        "path_type": "hardlink",
+        "sha256": "70ab05927c40337b1d9a8fc15edc220ba4482d8c886f26b0f5c306071e06851d",
+        "sha256_in_prefix": "70ab05927c40337b1d9a8fc15edc220ba4482d8c886f26b0f5c306071e06851d",
+        "size_in_bytes": 1913
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/flagup.xbm",
+        "path_type": "hardlink",
+        "sha256": "3d3d30b674eef51449465d387700bf8608931db54f67a93e015b9a4042f1e29c",
+        "sha256_in_prefix": "3d3d30b674eef51449465d387700bf8608931db54f67a93e015b9a4042f1e29c",
+        "size_in_bytes": 1907
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/gray25.xbm",
+        "path_type": "hardlink",
+        "sha256": "b637798957ed022067685e95c95e8c5e12c27b3443de3a8e5aa3ee0bb583bc28",
+        "sha256_in_prefix": "b637798957ed022067685e95c95e8c5e12c27b3443de3a8e5aa3ee0bb583bc28",
+        "size_in_bytes": 281
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/letters.xbm",
+        "path_type": "hardlink",
+        "sha256": "e82e3b9655519682ace59d217a004141dea420b5acb8eca08682066895855740",
+        "sha256_in_prefix": "e82e3b9655519682ace59d217a004141dea420b5acb8eca08682066895855740",
+        "size_in_bytes": 1910
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/noletter.xbm",
+        "path_type": "hardlink",
+        "sha256": "c6af489117974f9c43b681e340e0a25b7f0f97b7f615e8cb3062c26a3fb7b40e",
+        "sha256_in_prefix": "c6af489117974f9c43b681e340e0a25b7f0f97b7f615e8cb3062c26a3fb7b40e",
+        "size_in_bytes": 1916
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/ouster.png",
+        "path_type": "hardlink",
+        "sha256": "a2fe354dfcb09b9eeb488128f4ac0b498766faf4a8becf65bbcd779bdb9c4c8f",
+        "sha256_in_prefix": "a2fe354dfcb09b9eeb488128f4ac0b498766faf4a8becf65bbcd779bdb9c4c8f",
+        "size_in_bytes": 54257
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/pattern.xbm",
+        "path_type": "hardlink",
+        "sha256": "c5da801fa4ada674d951e154a4531a17f3201cee4af025800d3ccf98de860cad",
+        "sha256_in_prefix": "c5da801fa4ada674d951e154a4531a17f3201cee4af025800d3ccf98de860cad",
+        "size_in_bytes": 278
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/tcllogo.gif",
+        "path_type": "hardlink",
+        "sha256": "72f6b34d3c8f424ff0a290a793fcfbf34fd5630a916cd02e0a5dda0144b5957f",
+        "sha256_in_prefix": "72f6b34d3c8f424ff0a290a793fcfbf34fd5630a916cd02e0a5dda0144b5957f",
+        "size_in_bytes": 2341
+      },
+      {
+        "_path": "tcl/tk8.6/demos/images/teapot.ppm",
+        "path_type": "hardlink",
+        "sha256": "786f29b88771e439187dd2e86ad4d255dd185e0c1ea3f8c37d21770fd1df253a",
+        "sha256_in_prefix": "786f29b88771e439187dd2e86ad4d255dd185e0c1ea3f8c37d21770fd1df253a",
+        "size_in_bytes": 196623
+      },
+      {
+        "_path": "tcl/tk8.6/demos/items.tcl",
+        "path_type": "hardlink",
+        "sha256": "db098afb912829ef09a31c7a95c2a1c14f3ce0ff70c1271604d89b7c2143123d",
+        "sha256_in_prefix": "db098afb912829ef09a31c7a95c2a1c14f3ce0ff70c1271604d89b7c2143123d",
+        "size_in_bytes": 10792
+      },
+      {
+        "_path": "tcl/tk8.6/demos/ixset",
+        "path_type": "hardlink",
+        "sha256": "7ddeea934b567e8e5bee08e2a3767ddf40f015ab251bddd79a841cfec548e694",
+        "sha256_in_prefix": "7ddeea934b567e8e5bee08e2a3767ddf40f015ab251bddd79a841cfec548e694",
+        "size_in_bytes": 8400
+      },
+      {
+        "_path": "tcl/tk8.6/demos/knightstour.tcl",
+        "path_type": "hardlink",
+        "sha256": "8b4d0e72f828ad3a5420bf71f05a212ec32bd500c4645ca12a48dec4e0486a05",
+        "sha256_in_prefix": "8b4d0e72f828ad3a5420bf71f05a212ec32bd500c4645ca12a48dec4e0486a05",
+        "size_in_bytes": 9391
+      },
+      {
+        "_path": "tcl/tk8.6/demos/label.tcl",
+        "path_type": "hardlink",
+        "sha256": "6334ab83c8e2d2ba95debe678d5583ba7c74925e542047a4fe05554e69cf16e9",
+        "sha256_in_prefix": "6334ab83c8e2d2ba95debe678d5583ba7c74925e542047a4fe05554e69cf16e9",
+        "size_in_bytes": 1419
+      },
+      {
+        "_path": "tcl/tk8.6/demos/labelframe.tcl",
+        "path_type": "hardlink",
+        "sha256": "fb7f34effeff03dda13c4088fececa6d266ffbd87d3dad075a424c89305889e0",
+        "sha256_in_prefix": "fb7f34effeff03dda13c4088fececa6d266ffbd87d3dad075a424c89305889e0",
+        "size_in_bytes": 1923
+      },
+      {
+        "_path": "tcl/tk8.6/demos/license.terms",
+        "path_type": "hardlink",
+        "sha256": "0d1e4405f6273f091732764ed89b57066be63ce64869be6c71ea337dc4f2f9b5",
+        "sha256_in_prefix": "0d1e4405f6273f091732764ed89b57066be63ce64869be6c71ea337dc4f2f9b5",
+        "size_in_bytes": 2307
+      },
+      {
+        "_path": "tcl/tk8.6/demos/mclist.tcl",
+        "path_type": "hardlink",
+        "sha256": "737c1c78127865b8f3a359ec8f6d8675146547e043d9874f6e49d44680ed1c8a",
+        "sha256_in_prefix": "737c1c78127865b8f3a359ec8f6d8675146547e043d9874f6e49d44680ed1c8a",
+        "size_in_bytes": 4476
+      },
+      {
+        "_path": "tcl/tk8.6/demos/menu.tcl",
+        "path_type": "hardlink",
+        "sha256": "43e808c17c0078972ede7e8926413e64d7287992c2b8ef5d4b04d554b89799da",
+        "sha256_in_prefix": "43e808c17c0078972ede7e8926413e64d7287992c2b8ef5d4b04d554b89799da",
+        "size_in_bytes": 7659
+      },
+      {
+        "_path": "tcl/tk8.6/demos/menubu.tcl",
+        "path_type": "hardlink",
+        "sha256": "a9e0117d3f18153169bcf98e7363bd0112cea5762a43ff0fa83e9c681454d3a9",
+        "sha256_in_prefix": "a9e0117d3f18153169bcf98e7363bd0112cea5762a43ff0fa83e9c681454d3a9",
+        "size_in_bytes": 4566
+      },
+      {
+        "_path": "tcl/tk8.6/demos/msgbox.tcl",
+        "path_type": "hardlink",
+        "sha256": "652e236850c86d7f924514255174738ba71a1f7a7ba739aae6734ebd328d5428",
+        "sha256_in_prefix": "652e236850c86d7f924514255174738ba71a1f7a7ba739aae6734ebd328d5428",
+        "size_in_bytes": 2060
+      },
+      {
+        "_path": "tcl/tk8.6/demos/nl.msg",
+        "path_type": "hardlink",
+        "sha256": "f527e0117feb1c9aca6d06dda1226c201e6deaf89efca171175d08e80a9712ab",
+        "sha256_in_prefix": "f527e0117feb1c9aca6d06dda1226c201e6deaf89efca171175d08e80a9712ab",
+        "size_in_bytes": 6875
+      },
+      {
+        "_path": "tcl/tk8.6/demos/paned1.tcl",
+        "path_type": "hardlink",
+        "sha256": "d98e8a9bc5332d9dbf4f00382f840af90ce95204b05326c56cc079c27182d811",
+        "sha256_in_prefix": "d98e8a9bc5332d9dbf4f00382f840af90ce95204b05326c56cc079c27182d811",
+        "size_in_bytes": 1162
+      },
+      {
+        "_path": "tcl/tk8.6/demos/paned2.tcl",
+        "path_type": "hardlink",
+        "sha256": "c7684877a618c5bab0d0293662d76e5fdb231b479d8d9c0cb759e9af586ce6b2",
+        "sha256_in_prefix": "c7684877a618c5bab0d0293662d76e5fdb231b479d8d9c0cb759e9af586ce6b2",
+        "size_in_bytes": 2318
+      },
+      {
+        "_path": "tcl/tk8.6/demos/pendulum.tcl",
+        "path_type": "hardlink",
+        "sha256": "a00d1f68fbca9877a9f2269e324552a746f6a3babfb651cba0d39ba2bba0e8c5",
+        "sha256_in_prefix": "a00d1f68fbca9877a9f2269e324552a746f6a3babfb651cba0d39ba2bba0e8c5",
+        "size_in_bytes": 7820
+      },
+      {
+        "_path": "tcl/tk8.6/demos/plot.tcl",
+        "path_type": "hardlink",
+        "sha256": "897e231aea6c393571494dc4279f3d2d0206a7405740c2f601a1ca01b076e1a1",
+        "sha256_in_prefix": "897e231aea6c393571494dc4279f3d2d0206a7405740c2f601a1ca01b076e1a1",
+        "size_in_bytes": 2854
+      },
+      {
+        "_path": "tcl/tk8.6/demos/puzzle.tcl",
+        "path_type": "hardlink",
+        "sha256": "f28b48fbe10e92fcb9f871017a40487d4e0d2880f456821ad2ad1b4e3549c100",
+        "sha256_in_prefix": "f28b48fbe10e92fcb9f871017a40487d4e0d2880f456821ad2ad1b4e3549c100",
+        "size_in_bytes": 2684
+      },
+      {
+        "_path": "tcl/tk8.6/demos/radio.tcl",
+        "path_type": "hardlink",
+        "sha256": "5dcfe813b024ded726e728e75e8ec718b1a2491d4dac47adb2ae432af0cd1f57",
+        "sha256_in_prefix": "5dcfe813b024ded726e728e75e8ec718b1a2491d4dac47adb2ae432af0cd1f57",
+        "size_in_bytes": 2818
+      },
+      {
+        "_path": "tcl/tk8.6/demos/rmt",
+        "path_type": "hardlink",
+        "sha256": "dbd680e536b4eb2a2d733f96bbf3b5712e66a4a9e0a49f440f4668c6ac1b719a",
+        "sha256_in_prefix": "dbd680e536b4eb2a2d733f96bbf3b5712e66a4a9e0a49f440f4668c6ac1b719a",
+        "size_in_bytes": 5526
+      },
+      {
+        "_path": "tcl/tk8.6/demos/rolodex",
+        "path_type": "hardlink",
+        "sha256": "b995670a0afe039aa2051e5fc3ca27a3a42fb1c359f3a32603500385037029c2",
+        "sha256_in_prefix": "b995670a0afe039aa2051e5fc3ca27a3a42fb1c359f3a32603500385037029c2",
+        "size_in_bytes": 8501
+      },
+      {
+        "_path": "tcl/tk8.6/demos/ruler.tcl",
+        "path_type": "hardlink",
+        "sha256": "fd94b05bc5e28e8e7a932af964e9544389b5ccd76498916762240e48d382d121",
+        "sha256_in_prefix": "fd94b05bc5e28e8e7a932af964e9544389b5ccd76498916762240e48d382d121",
+        "size_in_bytes": 5508
+      },
+      {
+        "_path": "tcl/tk8.6/demos/sayings.tcl",
+        "path_type": "hardlink",
+        "sha256": "cdd24db3c873d29539ab345a2d4035e22be2360bb61b4d1be8313fc129c57f6d",
+        "sha256_in_prefix": "cdd24db3c873d29539ab345a2d4035e22be2360bb61b4d1be8313fc129c57f6d",
+        "size_in_bytes": 2317
+      },
+      {
+        "_path": "tcl/tk8.6/demos/search.tcl",
+        "path_type": "hardlink",
+        "sha256": "bea80b1b64879f571576e21deb3d909b95418eac230376f3df68f757a7eddf02",
+        "sha256_in_prefix": "bea80b1b64879f571576e21deb3d909b95418eac230376f3df68f757a7eddf02",
+        "size_in_bytes": 4542
+      },
+      {
+        "_path": "tcl/tk8.6/demos/spin.tcl",
+        "path_type": "hardlink",
+        "sha256": "77c7708062e226c7b55d81b89481ea088935759449dc4af754399bf609f5bebd",
+        "sha256_in_prefix": "77c7708062e226c7b55d81b89481ea088935759449dc4af754399bf609f5bebd",
+        "size_in_bytes": 1873
+      },
+      {
+        "_path": "tcl/tk8.6/demos/square",
+        "path_type": "hardlink",
+        "sha256": "5fb92b6033f2d05915b984076971db0ef87bad1e463591f5ba9507bdaeb95966",
+        "sha256_in_prefix": "5fb92b6033f2d05915b984076971db0ef87bad1e463591f5ba9507bdaeb95966",
+        "size_in_bytes": 1385
+      },
+      {
+        "_path": "tcl/tk8.6/demos/states.tcl",
+        "path_type": "hardlink",
+        "sha256": "12efe21106986b06d1f65bd2734514707fa70a7a8282bbd59c681ba02b0c9361",
+        "sha256_in_prefix": "12efe21106986b06d1f65bd2734514707fa70a7a8282bbd59c681ba02b0c9361",
+        "size_in_bytes": 2102
+      },
+      {
+        "_path": "tcl/tk8.6/demos/style.tcl",
+        "path_type": "hardlink",
+        "sha256": "798f10af8f6dfdcb4f95d075224e6de051565d401aa28604a45005a592efb263",
+        "sha256_in_prefix": "798f10af8f6dfdcb4f95d075224e6de051565d401aa28604a45005a592efb263",
+        "size_in_bytes": 7098
+      },
+      {
+        "_path": "tcl/tk8.6/demos/tclIndex",
+        "path_type": "hardlink",
+        "sha256": "eb7a61ebdcf654c2ab1ad5b9444a115e40c90e8c88a8dc5b7b4870286ddb9241",
+        "sha256_in_prefix": "eb7a61ebdcf654c2ab1ad5b9444a115e40c90e8c88a8dc5b7b4870286ddb9241",
+        "size_in_bytes": 5365
+      },
+      {
+        "_path": "tcl/tk8.6/demos/tcolor",
+        "path_type": "hardlink",
+        "sha256": "cf3f2cf7a612675f640ca71744a5cb5437e94a70bcbfdb899ff3c257d3868eb1",
+        "sha256_in_prefix": "cf3f2cf7a612675f640ca71744a5cb5437e94a70bcbfdb899ff3c257d3868eb1",
+        "size_in_bytes": 11608
+      },
+      {
+        "_path": "tcl/tk8.6/demos/text.tcl",
+        "path_type": "hardlink",
+        "sha256": "bfbed67317a86fbce94321754ecad255b2de3ff5b7c735682daeabaaa9f0086a",
+        "sha256_in_prefix": "bfbed67317a86fbce94321754ecad255b2de3ff5b7c735682daeabaaa9f0086a",
+        "size_in_bytes": 4404
+      },
+      {
+        "_path": "tcl/tk8.6/demos/textpeer.tcl",
+        "path_type": "hardlink",
+        "sha256": "440f52dbedf0c2e4754c93971d478425c9e78f71db19df3274720903647c9e15",
+        "sha256_in_prefix": "440f52dbedf0c2e4754c93971d478425c9e78f71db19df3274720903647c9e15",
+        "size_in_bytes": 2250
+      },
+      {
+        "_path": "tcl/tk8.6/demos/timer",
+        "path_type": "hardlink",
+        "sha256": "4a0410f3c13a47eb52d55e781fb54b13d5a0dbeb88ba88ea6e9e74019ae21ddc",
+        "sha256_in_prefix": "4a0410f3c13a47eb52d55e781fb54b13d5a0dbeb88ba88ea6e9e74019ae21ddc",
+        "size_in_bytes": 1139
+      },
+      {
+        "_path": "tcl/tk8.6/demos/toolbar.tcl",
+        "path_type": "hardlink",
+        "sha256": "9c2d3b5fa57a402508fc9a4d9464cdaca10504cf85da8a2742693c42998cba64",
+        "sha256_in_prefix": "9c2d3b5fa57a402508fc9a4d9464cdaca10504cf85da8a2742693c42998cba64",
+        "size_in_bytes": 3364
+      },
+      {
+        "_path": "tcl/tk8.6/demos/tree.tcl",
+        "path_type": "hardlink",
+        "sha256": "62052568d2cca5ed1d9ff6ccaf3821601f8201106fab9095c20bc19585215535",
+        "sha256_in_prefix": "62052568d2cca5ed1d9ff6ccaf3821601f8201106fab9095c20bc19585215535",
+        "size_in_bytes": 3267
+      },
+      {
+        "_path": "tcl/tk8.6/demos/ttkbut.tcl",
+        "path_type": "hardlink",
+        "sha256": "e1e26aa0622d79b6532b54e4ece6d9136d36c96dd6dacea1eddebf2bb07cb9cc",
+        "sha256_in_prefix": "e1e26aa0622d79b6532b54e4ece6d9136d36c96dd6dacea1eddebf2bb07cb9cc",
+        "size_in_bytes": 3489
+      },
+      {
+        "_path": "tcl/tk8.6/demos/ttkmenu.tcl",
+        "path_type": "hardlink",
+        "sha256": "4a96e4e93976351658fefb2e4bc7371f68d4ae3bd1775f590938abed0ade103f",
+        "sha256_in_prefix": "4a96e4e93976351658fefb2e4bc7371f68d4ae3bd1775f590938abed0ade103f",
+        "size_in_bytes": 2444
+      },
+      {
+        "_path": "tcl/tk8.6/demos/ttknote.tcl",
+        "path_type": "hardlink",
+        "sha256": "b8ab22ddd00a2583ecb7bc6e0f71a800dffe71d587567b1aaa571af9440175e0",
+        "sha256_in_prefix": "b8ab22ddd00a2583ecb7bc6e0f71a800dffe71d587567b1aaa571af9440175e0",
+        "size_in_bytes": 2374
+      },
+      {
+        "_path": "tcl/tk8.6/demos/ttkpane.tcl",
+        "path_type": "hardlink",
+        "sha256": "e1c472dcc79ab4826796848e320fc8769bc9daf6fe0378995054686a006d2c14",
+        "sha256_in_prefix": "e1c472dcc79ab4826796848e320fc8769bc9daf6fe0378995054686a006d2c14",
+        "size_in_bytes": 4289
+      },
+      {
+        "_path": "tcl/tk8.6/demos/ttkprogress.tcl",
+        "path_type": "hardlink",
+        "sha256": "340104a560226fd7e82de93b58e3ba4a56423c3d3f8c94b440287edc3ff5119e",
+        "sha256_in_prefix": "340104a560226fd7e82de93b58e3ba4a56423c3d3f8c94b440287edc3ff5119e",
+        "size_in_bytes": 1582
+      },
+      {
+        "_path": "tcl/tk8.6/demos/ttkscale.tcl",
+        "path_type": "hardlink",
+        "sha256": "2baa67e262de37b50615a9999c624ee05ce02b255334516c548ea845f7d4c470",
+        "sha256_in_prefix": "2baa67e262de37b50615a9999c624ee05ce02b255334516c548ea845f7d4c470",
+        "size_in_bytes": 1459
+      },
+      {
+        "_path": "tcl/tk8.6/demos/twind.tcl",
+        "path_type": "hardlink",
+        "sha256": "36b00de2b67c0974873787b4ff033f169f7201ab88e926fb4058f5cbb0298284",
+        "sha256_in_prefix": "36b00de2b67c0974873787b4ff033f169f7201ab88e926fb4058f5cbb0298284",
+        "size_in_bytes": 12005
+      },
+      {
+        "_path": "tcl/tk8.6/demos/unicodeout.tcl",
+        "path_type": "hardlink",
+        "sha256": "a5cc2cd45093b91cefaca4842055b89aa193cdc8a8c21ac5b049d15a7a1d044d",
+        "sha256_in_prefix": "a5cc2cd45093b91cefaca4842055b89aa193cdc8a8c21ac5b049d15a7a1d044d",
+        "size_in_bytes": 4851
+      },
+      {
+        "_path": "tcl/tk8.6/demos/vscale.tcl",
+        "path_type": "hardlink",
+        "sha256": "4c54f3b13268f6f96898b974b5bd185dcb59384096a3b1a3deff93b5361eea1a",
+        "sha256_in_prefix": "4c54f3b13268f6f96898b974b5bd185dcb59384096a3b1a3deff93b5361eea1a",
+        "size_in_bytes": 1523
+      },
+      {
+        "_path": "tcl/tk8.6/demos/widget",
+        "path_type": "hardlink",
+        "sha256": "01bef967805998261dc10784f974d86679a8c2d51b49cd1461ffc9b9340a034f",
+        "sha256_in_prefix": "01bef967805998261dc10784f974d86679a8c2d51b49cd1461ffc9b9340a034f",
+        "size_in_bytes": 24794
+      },
+      {
+        "_path": "tcl/tk8.6/dialog.tcl",
+        "path_type": "hardlink",
+        "sha256": "1c977052c1d8293cc5fe4198a538beca9bc821af85e76e4eefbfb75b33ce8bed",
+        "sha256_in_prefix": "1c977052c1d8293cc5fe4198a538beca9bc821af85e76e4eefbfb75b33ce8bed",
+        "size_in_bytes": 5988
+      },
+      {
+        "_path": "tcl/tk8.6/entry.tcl",
+        "path_type": "hardlink",
+        "sha256": "af1de90270693273b52fc735da6b5cd5ca794f5afd4cf03ffd95147161098048",
+        "sha256_in_prefix": "af1de90270693273b52fc735da6b5cd5ca794f5afd4cf03ffd95147161098048",
+        "size_in_bytes": 18401
+      },
+      {
+        "_path": "tcl/tk8.6/focus.tcl",
+        "path_type": "hardlink",
+        "sha256": "8872f236d7e824aec0acd4bacc00fdd7ec9bc5534814ecf2160610c10647b7c5",
+        "sha256_in_prefix": "8872f236d7e824aec0acd4bacc00fdd7ec9bc5534814ecf2160610c10647b7c5",
+        "size_in_bytes": 5035
+      },
+      {
+        "_path": "tcl/tk8.6/fontchooser.tcl",
+        "path_type": "hardlink",
+        "sha256": "48c6d9eabb028a57291c009e1b02756d1ea6a18f9aca7066c59bc3c5d881d3a6",
+        "sha256_in_prefix": "48c6d9eabb028a57291c009e1b02756d1ea6a18f9aca7066c59bc3c5d881d3a6",
+        "size_in_bytes": 16467
+      },
+      {
+        "_path": "tcl/tk8.6/iconlist.tcl",
+        "path_type": "hardlink",
+        "sha256": "c8b4b2130c6ad658331c59f41d8bdbab44e0011781214a0b0be78c4920536b2e",
+        "sha256_in_prefix": "c8b4b2130c6ad658331c59f41d8bdbab44e0011781214a0b0be78c4920536b2e",
+        "size_in_bytes": 17421
+      },
+      {
+        "_path": "tcl/tk8.6/icons.tcl",
+        "path_type": "hardlink",
+        "sha256": "1264940e62b9a37967925418e9d0dc0befd369e8c181b9bab3d1607e3cc14b85",
+        "sha256_in_prefix": "1264940e62b9a37967925418e9d0dc0befd369e8c181b9bab3d1607e3cc14b85",
+        "size_in_bytes": 11037
+      },
+      {
+        "_path": "tcl/tk8.6/images/README",
+        "path_type": "hardlink",
+        "sha256": "c6db098ebd8a622164d37d4ab0a8c205db1a83ac3065d5cde3cb5fb61925d283",
+        "sha256_in_prefix": "c6db098ebd8a622164d37d4ab0a8c205db1a83ac3065d5cde3cb5fb61925d283",
+        "size_in_bytes": 329
+      },
+      {
+        "_path": "tcl/tk8.6/images/logo.eps",
+        "path_type": "hardlink",
+        "sha256": "76207d8dfde189a29dc0e76adb7eaaa606b96bc6c1c831f34d1c85b1c5b51dd3",
+        "sha256_in_prefix": "76207d8dfde189a29dc0e76adb7eaaa606b96bc6c1c831f34d1c85b1c5b51dd3",
+        "size_in_bytes": 34991
+      },
+      {
+        "_path": "tcl/tk8.6/images/logo100.gif",
+        "path_type": "hardlink",
+        "sha256": "72f6b34d3c8f424ff0a290a793fcfbf34fd5630a916cd02e0a5dda0144b5957f",
+        "sha256_in_prefix": "72f6b34d3c8f424ff0a290a793fcfbf34fd5630a916cd02e0a5dda0144b5957f",
+        "size_in_bytes": 2341
+      },
+      {
+        "_path": "tcl/tk8.6/images/logo64.gif",
+        "path_type": "hardlink",
+        "sha256": "138c240382304f350383b02ed56c69103a9431c0544eb1ec5dcd7dec7a555dd9",
+        "sha256_in_prefix": "138c240382304f350383b02ed56c69103a9431c0544eb1ec5dcd7dec7a555dd9",
+        "size_in_bytes": 1670
+      },
+      {
+        "_path": "tcl/tk8.6/images/logoLarge.gif",
+        "path_type": "hardlink",
+        "sha256": "0f404764d07a6ae2ef9e1e0e8eaac278b7d488d61cf1c084146f2f33b485f2ed",
+        "sha256_in_prefix": "0f404764d07a6ae2ef9e1e0e8eaac278b7d488d61cf1c084146f2f33b485f2ed",
+        "size_in_bytes": 11000
+      },
+      {
+        "_path": "tcl/tk8.6/images/logoMed.gif",
+        "path_type": "hardlink",
+        "sha256": "4d0bd3228ab4cc3e5159f4337be969ec7b7334e265c99b7633e3daf3c3fcfb62",
+        "sha256_in_prefix": "4d0bd3228ab4cc3e5159f4337be969ec7b7334e265c99b7633e3daf3c3fcfb62",
+        "size_in_bytes": 3889
+      },
+      {
+        "_path": "tcl/tk8.6/images/pwrdLogo.eps",
+        "path_type": "hardlink",
+        "sha256": "87fd9e46dbb5f2bf1529afb411182c9fb9c58e23d830c66a233af0c256bb8eff",
+        "sha256_in_prefix": "87fd9e46dbb5f2bf1529afb411182c9fb9c58e23d830c66a233af0c256bb8eff",
+        "size_in_bytes": 29706
+      },
+      {
+        "_path": "tcl/tk8.6/images/pwrdLogo100.gif",
+        "path_type": "hardlink",
+        "sha256": "bcc0e6458249433e8cba6c58122b7c0efa9557cbc8fb5f9392eed5d2579fc70b",
+        "sha256_in_prefix": "bcc0e6458249433e8cba6c58122b7c0efa9557cbc8fb5f9392eed5d2579fc70b",
+        "size_in_bytes": 1615
+      },
+      {
+        "_path": "tcl/tk8.6/images/pwrdLogo150.gif",
+        "path_type": "hardlink",
+        "sha256": "5fc25c30aee76477f1c4e922931cc806823df059525583ff5705705d9e913c1c",
+        "sha256_in_prefix": "5fc25c30aee76477f1c4e922931cc806823df059525583ff5705705d9e913c1c",
+        "size_in_bytes": 2489
+      },
+      {
+        "_path": "tcl/tk8.6/images/pwrdLogo175.gif",
+        "path_type": "hardlink",
+        "sha256": "62866e95501c436b329a15432355743c6efd64a37cfb65bcece465ab63ecf240",
+        "sha256_in_prefix": "62866e95501c436b329a15432355743c6efd64a37cfb65bcece465ab63ecf240",
+        "size_in_bytes": 2981
+      },
+      {
+        "_path": "tcl/tk8.6/images/pwrdLogo200.gif",
+        "path_type": "hardlink",
+        "sha256": "bad9116386343f4a4c394bdb87146e49f674f687d52bb847bd9e8198fda382cc",
+        "sha256_in_prefix": "bad9116386343f4a4c394bdb87146e49f674f687d52bb847bd9e8198fda382cc",
+        "size_in_bytes": 3491
+      },
+      {
+        "_path": "tcl/tk8.6/images/pwrdLogo75.gif",
+        "path_type": "hardlink",
+        "sha256": "462a8ff8fd051a8100e8c6c086f497e4056ace5b20b44791f4aab964b010a448",
+        "sha256_in_prefix": "462a8ff8fd051a8100e8c6c086f497e4056ace5b20b44791f4aab964b010a448",
+        "size_in_bytes": 1171
+      },
+      {
+        "_path": "tcl/tk8.6/images/tai-ku.gif",
+        "path_type": "hardlink",
+        "sha256": "e538f8f4934ca6e1ce29416d292171f28e67da6c72ed9d236ba42f37445ea41e",
+        "sha256_in_prefix": "e538f8f4934ca6e1ce29416d292171f28e67da6c72ed9d236ba42f37445ea41e",
+        "size_in_bytes": 5473
+      },
+      {
+        "_path": "tcl/tk8.6/license.terms",
+        "path_type": "hardlink",
+        "sha256": "0d1e4405f6273f091732764ed89b57066be63ce64869be6c71ea337dc4f2f9b5",
+        "sha256_in_prefix": "0d1e4405f6273f091732764ed89b57066be63ce64869be6c71ea337dc4f2f9b5",
+        "size_in_bytes": 2307
+      },
+      {
+        "_path": "tcl/tk8.6/listbox.tcl",
+        "path_type": "hardlink",
+        "sha256": "47c75f9f8348bf8f2c086c57b97b73741218100ca38d10b8abdf2051c95b9801",
+        "sha256_in_prefix": "47c75f9f8348bf8f2c086c57b97b73741218100ca38d10b8abdf2051c95b9801",
+        "size_in_bytes": 15255
+      },
+      {
+        "_path": "tcl/tk8.6/megawidget.tcl",
+        "path_type": "hardlink",
+        "sha256": "848258b946c002e2696ca3815a1589c8120af5cc41fbc11bbd9a3f5754cc21af",
+        "sha256_in_prefix": "848258b946c002e2696ca3815a1589c8120af5cc41fbc11bbd9a3f5754cc21af",
+        "size_in_bytes": 9862
+      },
+      {
+        "_path": "tcl/tk8.6/menu.tcl",
+        "path_type": "hardlink",
+        "sha256": "d1283f67e435aab0bdbe9fdaa540a162043f8d652c02fe79f3843a451f123d89",
+        "sha256_in_prefix": "d1283f67e435aab0bdbe9fdaa540a162043f8d652c02fe79f3843a451f123d89",
+        "size_in_bytes": 39499
+      },
+      {
+        "_path": "tcl/tk8.6/mkpsenc.tcl",
+        "path_type": "hardlink",
+        "sha256": "c5bdca3aba671f03dc4624ab5fd260490f5002491d6c619142ccf5a1a744528a",
+        "sha256_in_prefix": "c5bdca3aba671f03dc4624ab5fd260490f5002491d6c619142ccf5a1a744528a",
+        "size_in_bytes": 30840
+      },
+      {
+        "_path": "tcl/tk8.6/msgbox.tcl",
+        "path_type": "hardlink",
+        "sha256": "a07e3a3809ced3c6c9c1e171dca5ad1f28357734cd41b2b9dd9f58085b3d2842",
+        "sha256_in_prefix": "a07e3a3809ced3c6c9c1e171dca5ad1f28357734cd41b2b9dd9f58085b3d2842",
+        "size_in_bytes": 16786
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/cs.msg",
+        "path_type": "hardlink",
+        "sha256": "4dffbeedbf0d66d84b13088016d1a782ceaad4ded27be1e38842f8969c0e533f",
+        "sha256_in_prefix": "4dffbeedbf0d66d84b13088016d1a782ceaad4ded27be1e38842f8969c0e533f",
+        "size_in_bytes": 4235
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/da.msg",
+        "path_type": "hardlink",
+        "sha256": "feef8f8ad33bb3362c845a25d6ed273c398051047d899b31790474614c7afd2d",
+        "sha256_in_prefix": "feef8f8ad33bb3362c845a25d6ed273c398051047d899b31790474614c7afd2d",
+        "size_in_bytes": 3987
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/de.msg",
+        "path_type": "hardlink",
+        "sha256": "c0f574b14068a049e93421c73873d750c98de28b7b77aa42fe72cbe0270a4186",
+        "sha256_in_prefix": "c0f574b14068a049e93421c73873d750c98de28b7b77aa42fe72cbe0270a4186",
+        "size_in_bytes": 4914
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/el.msg",
+        "path_type": "hardlink",
+        "sha256": "3f6f155864fe59a341bfd869735e54dd21cee21bbd038433d9b271ad77ba3f7e",
+        "sha256_in_prefix": "3f6f155864fe59a341bfd869735e54dd21cee21bbd038433d9b271ad77ba3f7e",
+        "size_in_bytes": 8784
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/en.msg",
+        "path_type": "hardlink",
+        "sha256": "4a33b44b2e220e28eaae7fac407cafe43d97c270da58fa5f3b699a1760bfb2a4",
+        "sha256_in_prefix": "4a33b44b2e220e28eaae7fac407cafe43d97c270da58fa5f3b699a1760bfb2a4",
+        "size_in_bytes": 3377
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/en_gb.msg",
+        "path_type": "hardlink",
+        "sha256": "01238293356e82f1d298896491f8b299bb7dc9c34f299c9e756254c736da612b",
+        "sha256_in_prefix": "01238293356e82f1d298896491f8b299bb7dc9c34f299c9e756254c736da612b",
+        "size_in_bytes": 66
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/eo.msg",
+        "path_type": "hardlink",
+        "sha256": "37fc66686349a955935cb24b0bd524e91823d2a631e63d54fdf17733c7502cbe",
+        "sha256_in_prefix": "37fc66686349a955935cb24b0bd524e91823d2a631e63d54fdf17733c7502cbe",
+        "size_in_bytes": 3991
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/es.msg",
+        "path_type": "hardlink",
+        "sha256": "d2842b80f1b521eff2d2656a69274b5f2a8f4f5831af2e8ee73e3c37389f981f",
+        "sha256_in_prefix": "d2842b80f1b521eff2d2656a69274b5f2a8f4f5831af2e8ee73e3c37389f981f",
+        "size_in_bytes": 4024
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/fr.msg",
+        "path_type": "hardlink",
+        "sha256": "3f2ceb4a33695ab6b56e27f61a4c60c029935bb026497d99cb2c246bcb4a63c4",
+        "sha256_in_prefix": "3f2ceb4a33695ab6b56e27f61a4c60c029935bb026497d99cb2c246bcb4a63c4",
+        "size_in_bytes": 3877
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/hu.msg",
+        "path_type": "hardlink",
+        "sha256": "e063ad7ca93f37728a65e4cd7c0433950f22607d307949f6cb056446afeaa4fe",
+        "sha256_in_prefix": "e063ad7ca93f37728a65e4cd7c0433950f22607d307949f6cb056446afeaa4fe",
+        "size_in_bytes": 4678
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/it.msg",
+        "path_type": "hardlink",
+        "sha256": "806930f283fd097195c7850e3486b3815d1564529b4f8e5fa6d26f3175183bc1",
+        "sha256_in_prefix": "806930f283fd097195c7850e3486b3815d1564529b4f8e5fa6d26f3175183bc1",
+        "size_in_bytes": 3765
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/nl.msg",
+        "path_type": "hardlink",
+        "sha256": "0914fba42361227d14fa281e8a9cbf57c16200b4da1e61cc3402ef0113a512c7",
+        "sha256_in_prefix": "0914fba42361227d14fa281e8a9cbf57c16200b4da1e61cc3402ef0113a512c7",
+        "size_in_bytes": 4557
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/pl.msg",
+        "path_type": "hardlink",
+        "sha256": "eaceb1f08de0863ccf726881e07fe5b135ea09646c5253e0cbf7ddb987eb0d92",
+        "sha256_in_prefix": "eaceb1f08de0863ccf726881e07fe5b135ea09646c5253e0cbf7ddb987eb0d92",
+        "size_in_bytes": 4932
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/pt.msg",
+        "path_type": "hardlink",
+        "sha256": "d687f71f0432bb0d02efdf576e526d2c19d4136f76c41a3224a2f034168f3f34",
+        "sha256_in_prefix": "d687f71f0432bb0d02efdf576e526d2c19d4136f76c41a3224a2f034168f3f34",
+        "size_in_bytes": 3987
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/ru.msg",
+        "path_type": "hardlink",
+        "sha256": "8715e9927ba925ae8099edf71a3d701fe396fc0e4df039cea7dc84120e101f47",
+        "sha256_in_prefix": "8715e9927ba925ae8099edf71a3d701fe396fc0e4df039cea7dc84120e101f47",
+        "size_in_bytes": 7289
+      },
+      {
+        "_path": "tcl/tk8.6/msgs/sv.msg",
+        "path_type": "hardlink",
+        "sha256": "a6821a13d34fb31f1827294b82c4bf9586bb255ca14f78c3ace11181f42ef211",
+        "sha256_in_prefix": "a6821a13d34fb31f1827294b82c4bf9586bb255ca14f78c3ace11181f42ef211",
+        "size_in_bytes": 3908
+      },
+      {
+        "_path": "tcl/tk8.6/obsolete.tcl",
+        "path_type": "hardlink",
+        "sha256": "540eeecba17207a56290baffdae882bbd4f88364791204ad5d14c7bedd022ccc",
+        "sha256_in_prefix": "540eeecba17207a56290baffdae882bbd4f88364791204ad5d14c7bedd022ccc",
+        "size_in_bytes": 5772
+      },
+      {
+        "_path": "tcl/tk8.6/optMenu.tcl",
+        "path_type": "hardlink",
+        "sha256": "40ca505c9784b0767d4854485c5c311829594a4fcbdfd7251e60e6bb7ea74fd1",
+        "sha256_in_prefix": "40ca505c9784b0767d4854485c5c311829594a4fcbdfd7251e60e6bb7ea74fd1",
+        "size_in_bytes": 1629
+      },
+      {
+        "_path": "tcl/tk8.6/palette.tcl",
+        "path_type": "hardlink",
+        "sha256": "849b4c57e4644e51beaeaeb3ae59b7ff067e582ecd10f1b2caf6b6e72f11f506",
+        "sha256_in_prefix": "849b4c57e4644e51beaeaeb3ae59b7ff067e582ecd10f1b2caf6b6e72f11f506",
+        "size_in_bytes": 8418
+      },
+      {
+        "_path": "tcl/tk8.6/panedwindow.tcl",
+        "path_type": "hardlink",
+        "sha256": "aa4f87e41ac8297f51150f2a9f787607690d01793456b93f0939c54d394731f9",
+        "sha256_in_prefix": "aa4f87e41ac8297f51150f2a9f787607690d01793456b93f0939c54d394731f9",
+        "size_in_bytes": 5370
+      },
+      {
+        "_path": "tcl/tk8.6/pkgIndex.tcl",
+        "path_type": "hardlink",
+        "sha256": "3f2539e85e2a9017913e61fe2600b499315e1a6f249a4ff90e0b530a1eeb8898",
+        "sha256_in_prefix": "3f2539e85e2a9017913e61fe2600b499315e1a6f249a4ff90e0b530a1eeb8898",
+        "size_in_bytes": 376
+      },
+      {
+        "_path": "tcl/tk8.6/safetk.tcl",
+        "path_type": "hardlink",
+        "sha256": "579701605669aadffbcdb7e3545c68442495428ee6e93c2d3a3133583bcd3d33",
+        "sha256_in_prefix": "579701605669aadffbcdb7e3545c68442495428ee6e93c2d3a3133583bcd3d33",
+        "size_in_bytes": 7632
+      },
+      {
+        "_path": "tcl/tk8.6/scale.tcl",
+        "path_type": "hardlink",
+        "sha256": "0da2dc955ffd71062a21c3b747d9d59d66a5b09a907b9ed220be1b2342205a05",
+        "sha256_in_prefix": "0da2dc955ffd71062a21c3b747d9d59d66a5b09a907b9ed220be1b2342205a05",
+        "size_in_bytes": 8056
+      },
+      {
+        "_path": "tcl/tk8.6/scrlbar.tcl",
+        "path_type": "hardlink",
+        "sha256": "eec90404f702d3cfbfaec0f13bf5ed1ebeb736bee12d7e69770181a25401c61f",
+        "sha256_in_prefix": "eec90404f702d3cfbfaec0f13bf5ed1ebeb736bee12d7e69770181a25401c61f",
+        "size_in_bytes": 13188
+      },
+      {
+        "_path": "tcl/tk8.6/spinbox.tcl",
+        "path_type": "hardlink",
+        "sha256": "2ff791a44406dc8339c7da6116e6ec92289bee5fc1367d378f48094f4abea277",
+        "sha256_in_prefix": "2ff791a44406dc8339c7da6116e6ec92289bee5fc1367d378f48094f4abea277",
+        "size_in_bytes": 16526
+      },
+      {
+        "_path": "tcl/tk8.6/tclIndex",
+        "path_type": "hardlink",
+        "sha256": "b04b1a675572e6fcd12c5fe82c4fd0930395548436ff93d848bf340ae202e7e3",
+        "sha256_in_prefix": "b04b1a675572e6fcd12c5fe82c4fd0930395548436ff93d848bf340ae202e7e3",
+        "size_in_bytes": 20523
+      },
+      {
+        "_path": "tcl/tk8.6/tearoff.tcl",
+        "path_type": "hardlink",
+        "sha256": "a4a8568633f827b54326640e6d1c3fde4978edc9e9fa1fb1d7b58f189df1b1dc",
+        "sha256_in_prefix": "a4a8568633f827b54326640e6d1c3fde4978edc9e9fa1fb1d7b58f189df1b1dc",
+        "size_in_bytes": 5309
+      },
+      {
+        "_path": "tcl/tk8.6/text.tcl",
+        "path_type": "hardlink",
+        "sha256": "4a42ad370e0cd93d4133b49788c0b0e1c7cd78383e88bacb51cb751e8bfda15e",
+        "sha256_in_prefix": "4a42ad370e0cd93d4133b49788c0b0e1c7cd78383e88bacb51cb751e8bfda15e",
+        "size_in_bytes": 34961
+      },
+      {
+        "_path": "tcl/tk8.6/tk.tcl",
+        "path_type": "hardlink",
+        "sha256": "0f617d96cbf213296d7a5f7fcffbb4ae1149840d7d045211ef932e8dd66683e9",
+        "sha256_in_prefix": "0f617d96cbf213296d7a5f7fcffbb4ae1149840d7d045211ef932e8dd66683e9",
+        "size_in_bytes": 24266
+      },
+      {
+        "_path": "tcl/tk8.6/tkfbox.tcl",
+        "path_type": "hardlink",
+        "sha256": "595a0b05eb2cbd4cf489e57624b509fc3b4885e6410ca6416e7521d23694373d",
+        "sha256_in_prefix": "595a0b05eb2cbd4cf489e57624b509fc3b4885e6410ca6416e7521d23694373d",
+        "size_in_bytes": 39613
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/altTheme.tcl",
+        "path_type": "hardlink",
+        "sha256": "ae0437fb4e0ebd31322e4eaca626c12abde602da483bb39d0c5ee1bc00ab0af4",
+        "sha256_in_prefix": "ae0437fb4e0ebd31322e4eaca626c12abde602da483bb39d0c5ee1bc00ab0af4",
+        "size_in_bytes": 3713
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/aquaTheme.tcl",
+        "path_type": "hardlink",
+        "sha256": "e199cc9c429b35a09721d0a22543c3729e2b8462e68dfa158c0cec9c70a0d79d",
+        "sha256_in_prefix": "e199cc9c429b35a09721d0a22543c3729e2b8462e68dfa158c0cec9c70a0d79d",
+        "size_in_bytes": 3838
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/button.tcl",
+        "path_type": "hardlink",
+        "sha256": "e38a9d1f437981aa6bf0bdd074d57b769a4140c0f7d9aff51743fe4ecc6dfddf",
+        "sha256_in_prefix": "e38a9d1f437981aa6bf0bdd074d57b769a4140c0f7d9aff51743fe4ecc6dfddf",
+        "size_in_bytes": 3014
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/clamTheme.tcl",
+        "path_type": "hardlink",
+        "sha256": "cffc59931fdd1683ad23895e92522cf49b099128753fcdff34374024e42cf995",
+        "sha256_in_prefix": "cffc59931fdd1683ad23895e92522cf49b099128753fcdff34374024e42cf995",
+        "size_in_bytes": 4809
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/classicTheme.tcl",
+        "path_type": "hardlink",
+        "sha256": "424bba4fb6836feebe34f6c176ed666dce51d2fba9a8d7aa756abcbbad3fc1e3",
+        "sha256_in_prefix": "424bba4fb6836feebe34f6c176ed666dce51d2fba9a8d7aa756abcbbad3fc1e3",
+        "size_in_bytes": 3864
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/combobox.tcl",
+        "path_type": "hardlink",
+        "sha256": "68eed4af6d2ec5b3ea24b1122a704b040366cbe2f458103137479352ffa1475a",
+        "sha256_in_prefix": "68eed4af6d2ec5b3ea24b1122a704b040366cbe2f458103137479352ffa1475a",
+        "size_in_bytes": 12718
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/cursors.tcl",
+        "path_type": "hardlink",
+        "sha256": "7a2ed9d78fabcafff16694f2f4a2e36ff5aa313f912d6e93484f3bcd0466ad91",
+        "sha256_in_prefix": "7a2ed9d78fabcafff16694f2f4a2e36ff5aa313f912d6e93484f3bcd0466ad91",
+        "size_in_bytes": 4827
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/defaults.tcl",
+        "path_type": "hardlink",
+        "sha256": "49ae8faf169165bddaf01d50b52943ebab3656e9468292b7890be143d0fcbc91",
+        "sha256_in_prefix": "49ae8faf169165bddaf01d50b52943ebab3656e9468292b7890be143d0fcbc91",
+        "size_in_bytes": 4553
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/entry.tcl",
+        "path_type": "hardlink",
+        "sha256": "830cc3009a735e92db70d53210c4928dd35caab5051ed14dec67e06ae25cbe28",
+        "sha256_in_prefix": "830cc3009a735e92db70d53210c4928dd35caab5051ed14dec67e06ae25cbe28",
+        "size_in_bytes": 17617
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/fonts.tcl",
+        "path_type": "hardlink",
+        "sha256": "b94c319e5a557a5665b1676d602b6495c0887c5bacf7fa5b776200112978bb7b",
+        "sha256_in_prefix": "b94c319e5a557a5665b1676d602b6495c0887c5bacf7fa5b776200112978bb7b",
+        "size_in_bytes": 5732
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/menubutton.tcl",
+        "path_type": "hardlink",
+        "sha256": "972b13854d0e9b84de338d6753f0f11f3a8534e7d0e51838796dae5a1e2e3085",
+        "sha256_in_prefix": "972b13854d0e9b84de338d6753f0f11f3a8534e7d0e51838796dae5a1e2e3085",
+        "size_in_bytes": 6641
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/notebook.tcl",
+        "path_type": "hardlink",
+        "sha256": "22264d8d138e2c0e9a950305b4f08557c5a73f054f8215c0d8ce03854042be76",
+        "sha256_in_prefix": "22264d8d138e2c0e9a950305b4f08557c5a73f054f8215c0d8ce03854042be76",
+        "size_in_bytes": 5825
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/panedwindow.tcl",
+        "path_type": "hardlink",
+        "sha256": "4d08a7e29eef731876951ef01dfa51654b6275fa3daadb1f48ff4bbeac238eb5",
+        "sha256_in_prefix": "4d08a7e29eef731876951ef01dfa51654b6275fa3daadb1f48ff4bbeac238eb5",
+        "size_in_bytes": 2290
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/progress.tcl",
+        "path_type": "hardlink",
+        "sha256": "697cc0a75ae31fe9c2d85fb25dca0afa5d0df9c523a2dfad2e4a36893be75fba",
+        "sha256_in_prefix": "697cc0a75ae31fe9c2d85fb25dca0afa5d0df9c523a2dfad2e4a36893be75fba",
+        "size_in_bytes": 1138
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/scale.tcl",
+        "path_type": "hardlink",
+        "sha256": "b909add0b87fa8ee08fd731041907212a8a0939d37d2ff9b2f600cd67dabd4bb",
+        "sha256_in_prefix": "b909add0b87fa8ee08fd731041907212a8a0939d37d2ff9b2f600cd67dabd4bb",
+        "size_in_bytes": 2787
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/scrollbar.tcl",
+        "path_type": "hardlink",
+        "sha256": "6eaa336b13815a7fc18bcd6b9adf722e794da2888d053c229044784c8c8e9de8",
+        "sha256_in_prefix": "6eaa336b13815a7fc18bcd6b9adf722e794da2888d053c229044784c8c8e9de8",
+        "size_in_bytes": 3285
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/sizegrip.tcl",
+        "path_type": "hardlink",
+        "sha256": "e92d77b5cdca2206376db2129e87e3d744b3d5e31fde6c0bbd44a494a6845ce1",
+        "sha256_in_prefix": "e92d77b5cdca2206376db2129e87e3d744b3d5e31fde6c0bbd44a494a6845ce1",
+        "size_in_bytes": 2503
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/spinbox.tcl",
+        "path_type": "hardlink",
+        "sha256": "df286bb59f471aa1e19df39af0ef7aa84df9f04dc4a439a747dd8ba43c300150",
+        "sha256_in_prefix": "df286bb59f471aa1e19df39af0ef7aa84df9f04dc4a439a747dd8ba43c300150",
+        "size_in_bytes": 5003
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/treeview.tcl",
+        "path_type": "hardlink",
+        "sha256": "c88b60ffb0f72e095f6fc9786930add7f9ed049eabc713f889f9a7da516e188c",
+        "sha256_in_prefix": "c88b60ffb0f72e095f6fc9786930add7f9ed049eabc713f889f9a7da516e188c",
+        "size_in_bytes": 10180
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/ttk.tcl",
+        "path_type": "hardlink",
+        "sha256": "2c48343b1a47f472d1a6b9ee8d670ce7fb428db0db7244dc323ff4c7a8b4f64b",
+        "sha256_in_prefix": "2c48343b1a47f472d1a6b9ee8d670ce7fb428db0db7244dc323ff4c7a8b4f64b",
+        "size_in_bytes": 4993
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/utils.tcl",
+        "path_type": "hardlink",
+        "sha256": "d58610a34301bb6e61a60bec69a7cecf4c45c6a034a9fc123977174b586278be",
+        "sha256_in_prefix": "d58610a34301bb6e61a60bec69a7cecf4c45c6a034a9fc123977174b586278be",
+        "size_in_bytes": 8624
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/vistaTheme.tcl",
+        "path_type": "hardlink",
+        "sha256": "ec5f203c69df390e9b99944cf3526d6e77dc6f68e9b1a029f326a41afed1ef81",
+        "sha256_in_prefix": "ec5f203c69df390e9b99944cf3526d6e77dc6f68e9b1a029f326a41afed1ef81",
+        "size_in_bytes": 9710
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/winTheme.tcl",
+        "path_type": "hardlink",
+        "sha256": "ae82bccce708ff9c303cbcb3d4cc3ff5577a60d5b23822ea79e3e07cce3cbbd1",
+        "sha256_in_prefix": "ae82bccce708ff9c303cbcb3d4cc3ff5577a60d5b23822ea79e3e07cce3cbbd1",
+        "size_in_bytes": 2865
+      },
+      {
+        "_path": "tcl/tk8.6/ttk/xpTheme.tcl",
+        "path_type": "hardlink",
+        "sha256": "aedb21c6b2909a4bb4686837d2126e521a8cc2b38414a4540387b801ebd75466",
+        "sha256_in_prefix": "aedb21c6b2909a4bb4686837d2126e521a8cc2b38414a4540387b801ebd75466",
+        "size_in_bytes": 2103
+      },
+      {
+        "_path": "tcl/tk8.6/unsupported.tcl",
+        "path_type": "hardlink",
+        "sha256": "b463b366f139ddf7fed31f34c6d2341f9f27845a1a358011dfc801e1333b1828",
+        "sha256_in_prefix": "b463b366f139ddf7fed31f34c6d2341f9f27845a1a358011dfc801e1333b1828",
+        "size_in_bytes": 10521
+      },
+      {
+        "_path": "tcl/tk8.6/xmfbox.tcl",
+        "path_type": "hardlink",
+        "sha256": "1ed57e32ce9c419bce36b483a91410ddf4c997caf62d20e42048fc350f8c3f60",
+        "sha256_in_prefix": "1ed57e32ce9c419bce36b483a91410ddf4c997caf62d20e42048fc350f8c3f60",
+        "size_in_bytes": 27064
+      },
+      {
+        "_path": "tcl/tk86t.lib",
+        "path_type": "hardlink",
+        "sha256": "584edf3e098277bfb49425b2d8a256867a9ce011e2e5f2e4098614cb176bf1a9",
+        "sha256_in_prefix": "584edf3e098277bfb49425b2d8a256867a9ce011e2e5f2e4098614cb176bf1a9",
+        "size_in_bytes": 125062
+      },
+      {
+        "_path": "tcl/tkstub86.lib",
+        "path_type": "hardlink",
+        "sha256": "d61c11087a59d29c71304790167714d176ed859c968799297f9993c3af5ea0cc",
+        "sha256_in_prefix": "d61c11087a59d29c71304790167714d176ed859c968799297f9993c3af5ea0cc",
+        "size_in_bytes": 7836
+      },
+      {
+        "_path": "venvlauncher.exe",
+        "path_type": "hardlink",
+        "sha256": "3cfe6b2ca91cb303d7067e38e7779b9566d93474131d1d2487e2c2fbad3e725d",
+        "sha256_in_prefix": "3cfe6b2ca91cb303d7067e38e7779b9566d93474131d1d2487e2c2fbad3e725d",
+        "size_in_bytes": 606480
+      },
+      {
+        "_path": "venvwlauncher.exe",
+        "path_type": "hardlink",
+        "sha256": "15d1714ff078f70a2c9c5fbad28f672e505481cc3bcb9dab88835dd2d9477465",
+        "sha256_in_prefix": "15d1714ff078f70a2c9c5fbad28f672e505481cc3bcb9dab88835dd2d9477465",
+        "size_in_bytes": 605968
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "python=3.9",
+  "sha256": "d20bdb22a9ff93558fb533d4d9097fa0a9036225a3b05ec5633aa1005fb7bc84",
+  "size": 20578724,
+  "subdir": "win-64",
+  "timestamp": 1733936799216,
+  "track_features": "",
+  "url": "https://repo.anaconda.com/pkgs/main/win-64/python-3.9.21-h8205438_1.conda",
+  "version": "3.9.21"
+}
\ No newline at end of file
diff --git a/marketing/conda-meta/setuptools-75.8.0-py39haa95532_0.json b/marketing/conda-meta/setuptools-75.8.0-py39haa95532_0.json
new file mode 100644
index 0000000000000000000000000000000000000000..90f14bfacd78406a573e4b7c58024542d373fbb1
--- /dev/null
+++ b/marketing/conda-meta/setuptools-75.8.0-py39haa95532_0.json
@@ -0,0 +1,6854 @@
+{
+  "build": "py39haa95532_0",
+  "build_number": 0,
+  "channel": "https://repo.anaconda.com/pkgs/main/win-64",
+  "constrains": [],
+  "depends": [
+    "python >=3.9,<3.10.0a0"
+  ],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\setuptools-75.8.0-py39haa95532_0",
+  "features": "",
+  "files": [
+    "Lib/site-packages/_distutils_hack/__init__.py",
+    "Lib/site-packages/_distutils_hack/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/_distutils_hack/__pycache__/override.cpython-39.pyc",
+    "Lib/site-packages/_distutils_hack/override.py",
+    "Lib/site-packages/distutils-precedence.pth",
+    "Lib/site-packages/pkg_resources/__init__.py",
+    "Lib/site-packages/pkg_resources/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pkg_resources/api_tests.txt",
+    "Lib/site-packages/pkg_resources/py.typed",
+    "Lib/site-packages/pkg_resources/tests/__init__.py",
+    "Lib/site-packages/pkg_resources/tests/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/pkg_resources/tests/__pycache__/test_find_distributions.cpython-39.pyc",
+    "Lib/site-packages/pkg_resources/tests/__pycache__/test_integration_zope_interface.cpython-39.pyc",
+    "Lib/site-packages/pkg_resources/tests/__pycache__/test_markers.cpython-39.pyc",
+    "Lib/site-packages/pkg_resources/tests/__pycache__/test_pkg_resources.cpython-39.pyc",
+    "Lib/site-packages/pkg_resources/tests/__pycache__/test_resources.cpython-39.pyc",
+    "Lib/site-packages/pkg_resources/tests/__pycache__/test_working_set.cpython-39.pyc",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package-source/__pycache__/setup.cpython-39.pyc",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package-source/setup.cfg",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package-source/setup.py",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package-zip/my-test-package.zip",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe",
+    "Lib/site-packages/pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg",
+    "Lib/site-packages/pkg_resources/tests/test_find_distributions.py",
+    "Lib/site-packages/pkg_resources/tests/test_integration_zope_interface.py",
+    "Lib/site-packages/pkg_resources/tests/test_markers.py",
+    "Lib/site-packages/pkg_resources/tests/test_pkg_resources.py",
+    "Lib/site-packages/pkg_resources/tests/test_resources.py",
+    "Lib/site-packages/pkg_resources/tests/test_working_set.py",
+    "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/PKG-INFO",
+    "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/SOURCES.txt",
+    "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/dependency_links.txt",
+    "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/entry_points.txt",
+    "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/requires.txt",
+    "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/top_level.txt",
+    "Lib/site-packages/setuptools/__init__.py",
+    "Lib/site-packages/setuptools/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_core_metadata.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_entry_points.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_imp.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_importlib.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_itertools.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_normalization.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_path.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_reqs.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_shutil.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/_static.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/archive_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/build_meta.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/depends.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/discovery.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/dist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/errors.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/extension.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/glob.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/installer.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/launch.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/logging.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/modified.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/monkey.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/msvc.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/namespaces.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/package_index.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/sandbox.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/unicode_utils.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/version.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/warnings.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/wheel.cpython-39.pyc",
+    "Lib/site-packages/setuptools/__pycache__/windows_support.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_core_metadata.py",
+    "Lib/site-packages/setuptools/_distutils/__init__.py",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/_log.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/_macos_compat.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/_modified.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/_msvccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/archive_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/ccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/cmd.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/core.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/cygwinccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/debug.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/dep_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/dir_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/dist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/errors.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/extension.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/fancy_getopt.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/file_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/filelist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/log.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/spawn.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/sysconfig.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/text_file.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/unixccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/version.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/versionpredicate.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/__pycache__/zosccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/_log.py",
+    "Lib/site-packages/setuptools/_distutils/_macos_compat.py",
+    "Lib/site-packages/setuptools/_distutils/_modified.py",
+    "Lib/site-packages/setuptools/_distutils/_msvccompiler.py",
+    "Lib/site-packages/setuptools/_distutils/archive_util.py",
+    "Lib/site-packages/setuptools/_distutils/ccompiler.py",
+    "Lib/site-packages/setuptools/_distutils/cmd.py",
+    "Lib/site-packages/setuptools/_distutils/command/__init__.py",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/_framework_compat.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/bdist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/build.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/build_clib.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/build_ext.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/build_py.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/build_scripts.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/check.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/clean.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/config.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/install.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_data.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_egg_info.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_headers.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_lib.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_scripts.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/__pycache__/sdist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/command/_framework_compat.py",
+    "Lib/site-packages/setuptools/_distutils/command/bdist.py",
+    "Lib/site-packages/setuptools/_distutils/command/bdist_dumb.py",
+    "Lib/site-packages/setuptools/_distutils/command/bdist_rpm.py",
+    "Lib/site-packages/setuptools/_distutils/command/build.py",
+    "Lib/site-packages/setuptools/_distutils/command/build_clib.py",
+    "Lib/site-packages/setuptools/_distutils/command/build_ext.py",
+    "Lib/site-packages/setuptools/_distutils/command/build_py.py",
+    "Lib/site-packages/setuptools/_distutils/command/build_scripts.py",
+    "Lib/site-packages/setuptools/_distutils/command/check.py",
+    "Lib/site-packages/setuptools/_distutils/command/clean.py",
+    "Lib/site-packages/setuptools/_distutils/command/config.py",
+    "Lib/site-packages/setuptools/_distutils/command/install.py",
+    "Lib/site-packages/setuptools/_distutils/command/install_data.py",
+    "Lib/site-packages/setuptools/_distutils/command/install_egg_info.py",
+    "Lib/site-packages/setuptools/_distutils/command/install_headers.py",
+    "Lib/site-packages/setuptools/_distutils/command/install_lib.py",
+    "Lib/site-packages/setuptools/_distutils/command/install_scripts.py",
+    "Lib/site-packages/setuptools/_distutils/command/sdist.py",
+    "Lib/site-packages/setuptools/_distutils/compat/__init__.py",
+    "Lib/site-packages/setuptools/_distutils/compat/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/compat/__pycache__/py39.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/compat/py39.py",
+    "Lib/site-packages/setuptools/_distutils/core.py",
+    "Lib/site-packages/setuptools/_distutils/cygwinccompiler.py",
+    "Lib/site-packages/setuptools/_distutils/debug.py",
+    "Lib/site-packages/setuptools/_distutils/dep_util.py",
+    "Lib/site-packages/setuptools/_distutils/dir_util.py",
+    "Lib/site-packages/setuptools/_distutils/dist.py",
+    "Lib/site-packages/setuptools/_distutils/errors.py",
+    "Lib/site-packages/setuptools/_distutils/extension.py",
+    "Lib/site-packages/setuptools/_distutils/fancy_getopt.py",
+    "Lib/site-packages/setuptools/_distutils/file_util.py",
+    "Lib/site-packages/setuptools/_distutils/filelist.py",
+    "Lib/site-packages/setuptools/_distutils/log.py",
+    "Lib/site-packages/setuptools/_distutils/spawn.py",
+    "Lib/site-packages/setuptools/_distutils/sysconfig.py",
+    "Lib/site-packages/setuptools/_distutils/tests/__init__.py",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/support.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build_py.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build_scripts.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_ccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_check.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_clean.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_cmd.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_config_cmd.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_core.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_cygwinccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_dir_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_dist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_extension.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_file_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_filelist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install_data.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install_headers.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install_lib.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install_scripts.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_log.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_mingwccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_modified.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_msvccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_sdist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_spawn.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_sysconfig.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_text_file.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_unixccompiler.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_version.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/__pycache__/unix_compat.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/compat/__init__.py",
+    "Lib/site-packages/setuptools/_distutils/tests/compat/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/compat/__pycache__/py39.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_distutils/tests/compat/py39.py",
+    "Lib/site-packages/setuptools/_distutils/tests/support.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_archive_util.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_bdist.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_bdist_dumb.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_bdist_rpm.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_build.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_build_clib.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_build_ext.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_build_py.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_build_scripts.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_ccompiler.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_check.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_clean.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_cmd.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_config_cmd.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_core.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_cygwinccompiler.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_dir_util.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_dist.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_extension.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_file_util.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_filelist.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_install.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_install_data.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_install_headers.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_install_lib.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_install_scripts.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_log.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_mingwccompiler.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_modified.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_msvccompiler.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_sdist.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_spawn.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_sysconfig.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_text_file.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_unixccompiler.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_util.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_version.py",
+    "Lib/site-packages/setuptools/_distutils/tests/test_versionpredicate.py",
+    "Lib/site-packages/setuptools/_distutils/tests/unix_compat.py",
+    "Lib/site-packages/setuptools/_distutils/text_file.py",
+    "Lib/site-packages/setuptools/_distutils/unixccompiler.py",
+    "Lib/site-packages/setuptools/_distutils/util.py",
+    "Lib/site-packages/setuptools/_distutils/version.py",
+    "Lib/site-packages/setuptools/_distutils/versionpredicate.py",
+    "Lib/site-packages/setuptools/_distutils/zosccompiler.py",
+    "Lib/site-packages/setuptools/_entry_points.py",
+    "Lib/site-packages/setuptools/_imp.py",
+    "Lib/site-packages/setuptools/_importlib.py",
+    "Lib/site-packages/setuptools/_itertools.py",
+    "Lib/site-packages/setuptools/_normalization.py",
+    "Lib/site-packages/setuptools/_path.py",
+    "Lib/site-packages/setuptools/_reqs.py",
+    "Lib/site-packages/setuptools/_shutil.py",
+    "Lib/site-packages/setuptools/_static.py",
+    "Lib/site-packages/setuptools/_vendor/__pycache__/typing_extensions.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/autocommand/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/autoasync.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/autocommand.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/automain.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/autoparse.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/errors.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/autocommand/autoasync.py",
+    "Lib/site-packages/setuptools/_vendor/autocommand/autocommand.py",
+    "Lib/site-packages/setuptools/_vendor/autocommand/automain.py",
+    "Lib/site-packages/setuptools/_vendor/autocommand/autoparse.py",
+    "Lib/site-packages/setuptools/_vendor/autocommand/errors.py",
+    "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/backports/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/backports/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/backports/tarfile/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/backports/tarfile/__main__.py",
+    "Lib/site-packages/setuptools/_vendor/backports/tarfile/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/backports/tarfile/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/backports/tarfile/compat/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/py38.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/backports/tarfile/compat/py38.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_adapters.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_collections.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_compat.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_functools.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_itertools.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_meta.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_text.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/diagnose.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/_adapters.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/_collections.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/_compat.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/_functools.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/_itertools.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/_meta.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/_text.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/__pycache__/py311.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/__pycache__/py39.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/py311.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/py39.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/diagnose.py",
+    "Lib/site-packages/setuptools/_vendor/importlib_metadata/py.typed",
+    "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/inflect/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/inflect/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/inflect/compat/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/inflect/compat/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/inflect/compat/__pycache__/py38.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/inflect/compat/py38.py",
+    "Lib/site-packages/setuptools/_vendor/inflect/py.typed",
+    "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/jaraco/__pycache__/context.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/jaraco/collections/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/jaraco/collections/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/jaraco/collections/py.typed",
+    "Lib/site-packages/setuptools/_vendor/jaraco/context.py",
+    "Lib/site-packages/setuptools/_vendor/jaraco/functools/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/jaraco/functools/__init__.pyi",
+    "Lib/site-packages/setuptools/_vendor/jaraco/functools/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/jaraco/functools/py.typed",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/Lorem ipsum.txt",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/layouts.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/show-newlines.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/strip-prefix.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/to-dvorak.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/to-qwerty.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/layouts.py",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/show-newlines.py",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/strip-prefix.py",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/to-dvorak.py",
+    "Lib/site-packages/setuptools/_vendor/jaraco/text/to-qwerty.py",
+    "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/__init__.pyi",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/__pycache__/more.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/__pycache__/recipes.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/more.py",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/more.pyi",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/py.typed",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/recipes.py",
+    "Lib/site-packages/setuptools/_vendor/more_itertools/recipes.pyi",
+    "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/LICENSE.APACHE",
+    "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/LICENSE.BSD",
+    "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/packaging/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_elffile.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_manylinux.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_musllinux.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_parser.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_structures.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_tokenizer.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/markers.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/metadata.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/requirements.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/specifiers.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/tags.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/utils.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/version.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/_elffile.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/_manylinux.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/_musllinux.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/_parser.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/_structures.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/_tokenizer.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/licenses/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/licenses/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/licenses/__pycache__/_spdx.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/packaging/licenses/_spdx.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/markers.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/metadata.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/py.typed",
+    "Lib/site-packages/setuptools/_vendor/packaging/requirements.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/specifiers.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/tags.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/utils.py",
+    "Lib/site-packages/setuptools/_vendor/packaging/version.py",
+    "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/licenses/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__main__.py",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/android.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/api.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/macos.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/unix.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/version.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/windows.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/android.py",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/api.py",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/macos.py",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/py.typed",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/unix.py",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/version.py",
+    "Lib/site-packages/setuptools/_vendor/platformdirs/windows.py",
+    "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/tomli/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/tomli/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/tomli/__pycache__/_parser.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/tomli/__pycache__/_re.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/tomli/__pycache__/_types.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/tomli/_parser.py",
+    "Lib/site-packages/setuptools/_vendor/tomli/_re.py",
+    "Lib/site-packages/setuptools/_vendor/tomli/_types.py",
+    "Lib/site-packages/setuptools/_vendor/tomli/py.typed",
+    "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/entry_points.txt",
+    "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_checkers.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_config.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_decorators.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_exceptions.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_functions.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_importhook.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_memo.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_pytest_plugin.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_suppression.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_transformer.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_union_transformer.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_utils.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_checkers.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_config.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_decorators.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_exceptions.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_functions.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_importhook.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_memo.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_pytest_plugin.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_suppression.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_transformer.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_union_transformer.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/_utils.py",
+    "Lib/site-packages/setuptools/_vendor/typeguard/py.typed",
+    "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/typing_extensions.py",
+    "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/LICENSE.txt",
+    "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/entry_points.txt",
+    "Lib/site-packages/setuptools/_vendor/wheel/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/__main__.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/_setuptools_logging.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/bdist_wheel.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/macosx_libfile.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/metadata.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/wheelfile.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/_setuptools_logging.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/bdist_wheel.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/convert.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/pack.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/tags.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/unpack.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/convert.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/pack.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/tags.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/cli/unpack.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/macosx_libfile.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/metadata.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/util.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_elffile.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_manylinux.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_musllinux.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_parser.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_structures.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_tokenizer.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/markers.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/requirements.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/specifiers.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/tags.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/utils.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/version.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_elffile.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_manylinux.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_musllinux.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_parser.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_structures.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_tokenizer.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/markers.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/requirements.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/specifiers.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/tags.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/utils.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/version.py",
+    "Lib/site-packages/setuptools/_vendor/wheel/vendored/vendor.txt",
+    "Lib/site-packages/setuptools/_vendor/wheel/wheelfile.py",
+    "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/INSTALLER",
+    "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/LICENSE",
+    "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/METADATA",
+    "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/RECORD",
+    "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/REQUESTED",
+    "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/WHEEL",
+    "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/top_level.txt",
+    "Lib/site-packages/setuptools/_vendor/zipp/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/zipp/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/zipp/__pycache__/glob.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/zipp/compat/__init__.py",
+    "Lib/site-packages/setuptools/_vendor/zipp/compat/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/zipp/compat/__pycache__/py310.cpython-39.pyc",
+    "Lib/site-packages/setuptools/_vendor/zipp/compat/py310.py",
+    "Lib/site-packages/setuptools/_vendor/zipp/glob.py",
+    "Lib/site-packages/setuptools/archive_util.py",
+    "Lib/site-packages/setuptools/build_meta.py",
+    "Lib/site-packages/setuptools/cli-32.exe",
+    "Lib/site-packages/setuptools/cli-64.exe",
+    "Lib/site-packages/setuptools/cli-arm64.exe",
+    "Lib/site-packages/setuptools/cli.exe",
+    "Lib/site-packages/setuptools/command/__init__.py",
+    "Lib/site-packages/setuptools/command/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/_requirestxt.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/alias.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/bdist_egg.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/bdist_rpm.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/bdist_wheel.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/build.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/build_clib.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/build_ext.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/build_py.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/develop.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/dist_info.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/easy_install.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/editable_wheel.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/egg_info.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/install.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/install_egg_info.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/install_lib.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/install_scripts.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/rotate.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/saveopts.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/sdist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/setopt.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/__pycache__/test.cpython-39.pyc",
+    "Lib/site-packages/setuptools/command/_requirestxt.py",
+    "Lib/site-packages/setuptools/command/alias.py",
+    "Lib/site-packages/setuptools/command/bdist_egg.py",
+    "Lib/site-packages/setuptools/command/bdist_rpm.py",
+    "Lib/site-packages/setuptools/command/bdist_wheel.py",
+    "Lib/site-packages/setuptools/command/build.py",
+    "Lib/site-packages/setuptools/command/build_clib.py",
+    "Lib/site-packages/setuptools/command/build_ext.py",
+    "Lib/site-packages/setuptools/command/build_py.py",
+    "Lib/site-packages/setuptools/command/develop.py",
+    "Lib/site-packages/setuptools/command/dist_info.py",
+    "Lib/site-packages/setuptools/command/easy_install.py",
+    "Lib/site-packages/setuptools/command/editable_wheel.py",
+    "Lib/site-packages/setuptools/command/egg_info.py",
+    "Lib/site-packages/setuptools/command/install.py",
+    "Lib/site-packages/setuptools/command/install_egg_info.py",
+    "Lib/site-packages/setuptools/command/install_lib.py",
+    "Lib/site-packages/setuptools/command/install_scripts.py",
+    "Lib/site-packages/setuptools/command/launcher manifest.xml",
+    "Lib/site-packages/setuptools/command/rotate.py",
+    "Lib/site-packages/setuptools/command/saveopts.py",
+    "Lib/site-packages/setuptools/command/sdist.py",
+    "Lib/site-packages/setuptools/command/setopt.py",
+    "Lib/site-packages/setuptools/command/test.py",
+    "Lib/site-packages/setuptools/compat/__init__.py",
+    "Lib/site-packages/setuptools/compat/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/compat/__pycache__/py310.cpython-39.pyc",
+    "Lib/site-packages/setuptools/compat/__pycache__/py311.cpython-39.pyc",
+    "Lib/site-packages/setuptools/compat/__pycache__/py312.cpython-39.pyc",
+    "Lib/site-packages/setuptools/compat/__pycache__/py39.cpython-39.pyc",
+    "Lib/site-packages/setuptools/compat/py310.py",
+    "Lib/site-packages/setuptools/compat/py311.py",
+    "Lib/site-packages/setuptools/compat/py312.py",
+    "Lib/site-packages/setuptools/compat/py39.py",
+    "Lib/site-packages/setuptools/config/NOTICE",
+    "Lib/site-packages/setuptools/config/__init__.py",
+    "Lib/site-packages/setuptools/config/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/__pycache__/_apply_pyprojecttoml.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/__pycache__/expand.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/__pycache__/pyprojecttoml.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/__pycache__/setupcfg.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/_apply_pyprojecttoml.py",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/NOTICE",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/__init__.py",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/error_reporting.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/extra_validations.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_exceptions.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/formats.cpython-39.pyc",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/error_reporting.py",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/extra_validations.py",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_validations.py",
+    "Lib/site-packages/setuptools/config/_validate_pyproject/formats.py",
+    "Lib/site-packages/setuptools/config/distutils.schema.json",
+    "Lib/site-packages/setuptools/config/expand.py",
+    "Lib/site-packages/setuptools/config/pyprojecttoml.py",
+    "Lib/site-packages/setuptools/config/setupcfg.py",
+    "Lib/site-packages/setuptools/config/setuptools.schema.json",
+    "Lib/site-packages/setuptools/depends.py",
+    "Lib/site-packages/setuptools/discovery.py",
+    "Lib/site-packages/setuptools/dist.py",
+    "Lib/site-packages/setuptools/errors.py",
+    "Lib/site-packages/setuptools/extension.py",
+    "Lib/site-packages/setuptools/glob.py",
+    "Lib/site-packages/setuptools/gui-32.exe",
+    "Lib/site-packages/setuptools/gui-64.exe",
+    "Lib/site-packages/setuptools/gui-arm64.exe",
+    "Lib/site-packages/setuptools/gui.exe",
+    "Lib/site-packages/setuptools/installer.py",
+    "Lib/site-packages/setuptools/launch.py",
+    "Lib/site-packages/setuptools/logging.py",
+    "Lib/site-packages/setuptools/modified.py",
+    "Lib/site-packages/setuptools/monkey.py",
+    "Lib/site-packages/setuptools/msvc.py",
+    "Lib/site-packages/setuptools/namespaces.py",
+    "Lib/site-packages/setuptools/package_index.py",
+    "Lib/site-packages/setuptools/sandbox.py",
+    "Lib/site-packages/setuptools/script (dev).tmpl",
+    "Lib/site-packages/setuptools/script.tmpl",
+    "Lib/site-packages/setuptools/tests/__init__.py",
+    "Lib/site-packages/setuptools/tests/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/contexts.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/environment.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/fixtures.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/mod_with_constant.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/namespaces.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/script-with-bom.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/server.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_archive_util.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_bdist_deprecations.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_bdist_egg.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_bdist_wheel.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_build.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_build_clib.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_build_ext.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_build_meta.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_build_py.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_config_discovery.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_core_metadata.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_depends.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_develop.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_dist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_dist_info.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_distutils_adoption.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_easy_install.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_editable_install.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_egg_info.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_extern.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_find_packages.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_find_py_modules.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_glob.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_install_scripts.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_logging.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_manifest.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_namespaces.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_packageindex.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_sandbox.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_sdist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_setopt.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_setuptools.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_shutil_wrapper.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_unicode_utils.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_virtualenv.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_warnings.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_wheel.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/test_windows_wrappers.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/text.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/__pycache__/textwrap.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/compat/__init__.py",
+    "Lib/site-packages/setuptools/tests/compat/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/compat/__pycache__/py39.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/compat/py39.py",
+    "Lib/site-packages/setuptools/tests/config/__init__.py",
+    "Lib/site-packages/setuptools/tests/config/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/config/__pycache__/test_apply_pyprojecttoml.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/config/__pycache__/test_expand.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml_dynamic_deps.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/config/__pycache__/test_setupcfg.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/config/downloads/__init__.py",
+    "Lib/site-packages/setuptools/tests/config/downloads/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/config/downloads/__pycache__/preload.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/config/downloads/preload.py",
+    "Lib/site-packages/setuptools/tests/config/setupcfg_examples.txt",
+    "Lib/site-packages/setuptools/tests/config/test_apply_pyprojecttoml.py",
+    "Lib/site-packages/setuptools/tests/config/test_expand.py",
+    "Lib/site-packages/setuptools/tests/config/test_pyprojecttoml.py",
+    "Lib/site-packages/setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py",
+    "Lib/site-packages/setuptools/tests/config/test_setupcfg.py",
+    "Lib/site-packages/setuptools/tests/contexts.py",
+    "Lib/site-packages/setuptools/tests/environment.py",
+    "Lib/site-packages/setuptools/tests/fixtures.py",
+    "Lib/site-packages/setuptools/tests/indexes/test_links_priority/external.html",
+    "Lib/site-packages/setuptools/tests/indexes/test_links_priority/simple/foobar/index.html",
+    "Lib/site-packages/setuptools/tests/integration/__init__.py",
+    "Lib/site-packages/setuptools/tests/integration/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/integration/__pycache__/helpers.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/integration/__pycache__/test_pip_install_sdist.cpython-39.pyc",
+    "Lib/site-packages/setuptools/tests/integration/helpers.py",
+    "Lib/site-packages/setuptools/tests/integration/test_pip_install_sdist.py",
+    "Lib/site-packages/setuptools/tests/mod_with_constant.py",
+    "Lib/site-packages/setuptools/tests/namespaces.py",
+    "Lib/site-packages/setuptools/tests/script-with-bom.py",
+    "Lib/site-packages/setuptools/tests/server.py",
+    "Lib/site-packages/setuptools/tests/test_archive_util.py",
+    "Lib/site-packages/setuptools/tests/test_bdist_deprecations.py",
+    "Lib/site-packages/setuptools/tests/test_bdist_egg.py",
+    "Lib/site-packages/setuptools/tests/test_bdist_wheel.py",
+    "Lib/site-packages/setuptools/tests/test_build.py",
+    "Lib/site-packages/setuptools/tests/test_build_clib.py",
+    "Lib/site-packages/setuptools/tests/test_build_ext.py",
+    "Lib/site-packages/setuptools/tests/test_build_meta.py",
+    "Lib/site-packages/setuptools/tests/test_build_py.py",
+    "Lib/site-packages/setuptools/tests/test_config_discovery.py",
+    "Lib/site-packages/setuptools/tests/test_core_metadata.py",
+    "Lib/site-packages/setuptools/tests/test_depends.py",
+    "Lib/site-packages/setuptools/tests/test_develop.py",
+    "Lib/site-packages/setuptools/tests/test_dist.py",
+    "Lib/site-packages/setuptools/tests/test_dist_info.py",
+    "Lib/site-packages/setuptools/tests/test_distutils_adoption.py",
+    "Lib/site-packages/setuptools/tests/test_easy_install.py",
+    "Lib/site-packages/setuptools/tests/test_editable_install.py",
+    "Lib/site-packages/setuptools/tests/test_egg_info.py",
+    "Lib/site-packages/setuptools/tests/test_extern.py",
+    "Lib/site-packages/setuptools/tests/test_find_packages.py",
+    "Lib/site-packages/setuptools/tests/test_find_py_modules.py",
+    "Lib/site-packages/setuptools/tests/test_glob.py",
+    "Lib/site-packages/setuptools/tests/test_install_scripts.py",
+    "Lib/site-packages/setuptools/tests/test_logging.py",
+    "Lib/site-packages/setuptools/tests/test_manifest.py",
+    "Lib/site-packages/setuptools/tests/test_namespaces.py",
+    "Lib/site-packages/setuptools/tests/test_packageindex.py",
+    "Lib/site-packages/setuptools/tests/test_sandbox.py",
+    "Lib/site-packages/setuptools/tests/test_sdist.py",
+    "Lib/site-packages/setuptools/tests/test_setopt.py",
+    "Lib/site-packages/setuptools/tests/test_setuptools.py",
+    "Lib/site-packages/setuptools/tests/test_shutil_wrapper.py",
+    "Lib/site-packages/setuptools/tests/test_unicode_utils.py",
+    "Lib/site-packages/setuptools/tests/test_virtualenv.py",
+    "Lib/site-packages/setuptools/tests/test_warnings.py",
+    "Lib/site-packages/setuptools/tests/test_wheel.py",
+    "Lib/site-packages/setuptools/tests/test_windows_wrappers.py",
+    "Lib/site-packages/setuptools/tests/text.py",
+    "Lib/site-packages/setuptools/tests/textwrap.py",
+    "Lib/site-packages/setuptools/unicode_utils.py",
+    "Lib/site-packages/setuptools/version.py",
+    "Lib/site-packages/setuptools/warnings.py",
+    "Lib/site-packages/setuptools/wheel.py",
+    "Lib/site-packages/setuptools/windows_support.py",
+    ".nonadmin"
+  ],
+  "fn": "setuptools-75.8.0-py39haa95532_0.conda",
+  "legacy_bz2_md5": "3e19f4e71a8471967e83c31cd7d19d04",
+  "license": "MIT",
+  "license_family": "MIT",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\setuptools-75.8.0-py39haa95532_0",
+    "type": 1
+  },
+  "md5": "c5a0143e633d0855ac57d311f5620403",
+  "name": "setuptools",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\setuptools-75.8.0-py39haa95532_0.conda",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "Lib/site-packages/_distutils_hack/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "df81e6bcba34ee3e3952f776551fb669143b9490fdd6c4caeb32609f97e985b4",
+        "sha256_in_prefix": "df81e6bcba34ee3e3952f776551fb669143b9490fdd6c4caeb32609f97e985b4",
+        "size_in_bytes": 6755
+      },
+      {
+        "_path": "Lib/site-packages/_distutils_hack/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3bc2b21ffd849820fadf730360491477f70bec42a826e867fc556f614ec621cd",
+        "sha256_in_prefix": "3bc2b21ffd849820fadf730360491477f70bec42a826e867fc556f614ec621cd",
+        "size_in_bytes": 8150
+      },
+      {
+        "_path": "Lib/site-packages/_distutils_hack/__pycache__/override.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7fa9d91be913836d4a7468cff478049c7d6a9cc3e89cb75d84cafeefcf5838ef",
+        "sha256_in_prefix": "7fa9d91be913836d4a7468cff478049c7d6a9cc3e89cb75d84cafeefcf5838ef",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "Lib/site-packages/_distutils_hack/override.py",
+        "path_type": "hardlink",
+        "sha256": "12efecf8d17a5486780aa774b5b6c0e70b56932d8864f35df1eb7a18bb759b3a",
+        "sha256_in_prefix": "12efecf8d17a5486780aa774b5b6c0e70b56932d8864f35df1eb7a18bb759b3a",
+        "size_in_bytes": 44
+      },
+      {
+        "_path": "Lib/site-packages/distutils-precedence.pth",
+        "path_type": "hardlink",
+        "sha256": "ab406aa05439fe87070cde36180433193568432f11d04f0f762f374b8a9302f5",
+        "sha256_in_prefix": "ab406aa05439fe87070cde36180433193568432f11d04f0f762f374b8a9302f5",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "7eec9d77ef3ba27df5fb73f4c13353662167d2aba2635f2965d3facd15da950b",
+        "sha256_in_prefix": "7eec9d77ef3ba27df5fb73f4c13353662167d2aba2635f2965d3facd15da950b",
+        "size_in_bytes": 126098
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5934159889d268cdf72d79a5247d9c0529c0e01f09580d2dfcc65ff0be87033e",
+        "sha256_in_prefix": "5934159889d268cdf72d79a5247d9c0529c0e01f09580d2dfcc65ff0be87033e",
+        "size_in_bytes": 113788
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/api_tests.txt",
+        "path_type": "hardlink",
+        "sha256": "5c476fcb88a01c7aeadaa34734c1e795f3ba5d240a36a3b22c76e5e907297c02",
+        "sha256_in_prefix": "5c476fcb88a01c7aeadaa34734c1e795f3ba5d240a36a3b22c76e5e907297c02",
+        "size_in_bytes": 12595
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "14e44b7df468c3761de3920c5bba3652985f0e33d7860fa1434e9182d8db3266",
+        "sha256_in_prefix": "14e44b7df468c3761de3920c5bba3652985f0e33d7860fa1434e9182d8db3266",
+        "size_in_bytes": 140
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/__pycache__/test_find_distributions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2be7fb1a1e065d500a48b91dff117954fa31f4565573c2d4e30e74f24507aac0",
+        "sha256_in_prefix": "2be7fb1a1e065d500a48b91dff117954fa31f4565573c2d4e30e74f24507aac0",
+        "size_in_bytes": 2483
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/__pycache__/test_integration_zope_interface.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a55f3d6241c54e7118a97f8574abf13e1f62d8b2fcf9697feea6e61d2c7563a4",
+        "sha256_in_prefix": "a55f3d6241c54e7118a97f8574abf13e1f62d8b2fcf9697feea6e61d2c7563a4",
+        "size_in_bytes": 1542
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/__pycache__/test_markers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f8e853efd58a551a8b015f252fd179cad09bb1b8003dcefde4f78331268f55ee",
+        "sha256_in_prefix": "f8e853efd58a551a8b015f252fd179cad09bb1b8003dcefde4f78331268f55ee",
+        "size_in_bytes": 480
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/__pycache__/test_pkg_resources.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a7df5e13a90d2fb715e148cb94ab0d310254f04373fa474ab765309424c11cb5",
+        "sha256_in_prefix": "a7df5e13a90d2fb715e148cb94ab0d310254f04373fa474ab765309424c11cb5",
+        "size_in_bytes": 13547
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/__pycache__/test_resources.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7601c5aa8cca1258d173f2aedf99d2229ceeb7a135592caafa2f072410b386ca",
+        "sha256_in_prefix": "7601c5aa8cca1258d173f2aedf99d2229ceeb7a135592caafa2f072410b386ca",
+        "size_in_bytes": 28260
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/__pycache__/test_working_set.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "efa87d9f56d27117d456bd60f15ec06ab970368b722d5cb7dc58551910be0d8c",
+        "sha256_in_prefix": "efa87d9f56d27117d456bd60f15ec06ab970368b722d5cb7dc58551910be0d8c",
+        "size_in_bytes": 8353
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package-source/__pycache__/setup.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "07942d21f275b707a658826d71cccd6ece8a01168dd8e66f0cc144eabe1ba639",
+        "sha256_in_prefix": "07942d21f275b707a658826d71cccd6ece8a01168dd8e66f0cc144eabe1ba639",
+        "size_in_bytes": 270
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package-source/setup.cfg",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package-source/setup.py",
+        "path_type": "hardlink",
+        "sha256": "d55a1b84065b31beccf667e16ff344f0fc03b2fba4a162ecf5a5004b4a5885ef",
+        "sha256_in_prefix": "d55a1b84065b31beccf667e16ff344f0fc03b2fba4a162ecf5a5004b4a5885ef",
+        "size_in_bytes": 105
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package-zip/my-test-package.zip",
+        "path_type": "hardlink",
+        "sha256": "01845c437f4655e3cf9cc4fc4e49cfd607431f22675e1b611129a90239f34822",
+        "sha256_in_prefix": "01845c437f4655e3cf9cc4fc4e49cfd607431f22675e1b611129a90239f34822",
+        "size_in_bytes": 1809
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO",
+        "path_type": "hardlink",
+        "sha256": "26f5aff48a363c0b98c04130d9f056e1073962f75b92c729297d6498bceca079",
+        "sha256_in_prefix": "26f5aff48a363c0b98c04130d9f056e1073962f75b92c729297d6498bceca079",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt",
+        "path_type": "hardlink",
+        "sha256": "e029641fc793a2f66b755ac916c56ec5d6cc105fbe941552b8aa270c03c4e497",
+        "sha256_in_prefix": "e029641fc793a2f66b755ac916c56ec5d6cc105fbe941552b8aa270c03c4e497",
+        "size_in_bytes": 208
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt",
+        "path_type": "hardlink",
+        "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+        "sha256_in_prefix": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+        "size_in_bytes": 1
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+        "sha256_in_prefix": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+        "size_in_bytes": 1
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe",
+        "path_type": "hardlink",
+        "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+        "sha256_in_prefix": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+        "size_in_bytes": 1
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg",
+        "path_type": "hardlink",
+        "sha256": "65394c1b18d11a2283364880d9cef98db407d93588b5e3f4d22ac5f60bdccdba",
+        "sha256_in_prefix": "65394c1b18d11a2283364880d9cef98db407d93588b5e3f4d22ac5f60bdccdba",
+        "size_in_bytes": 843
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/test_find_distributions.py",
+        "path_type": "hardlink",
+        "sha256": "53dd5ca2fe4bd423802162cdab75f2e29954eff327384d56b5732eea2576c1a3",
+        "sha256_in_prefix": "53dd5ca2fe4bd423802162cdab75f2e29954eff327384d56b5732eea2576c1a3",
+        "size_in_bytes": 1972
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/test_integration_zope_interface.py",
+        "path_type": "hardlink",
+        "sha256": "9f35682b9e7b29940dd15dc3210d6c55e6823a0b782a997e08e0c05ac3bba667",
+        "sha256_in_prefix": "9f35682b9e7b29940dd15dc3210d6c55e6823a0b782a997e08e0c05ac3bba667",
+        "size_in_bytes": 1652
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/test_markers.py",
+        "path_type": "hardlink",
+        "sha256": "d28aca83b50c0dfedf9ee350bd130e73e105f4400ffc94d09e4e26b4681b5b9d",
+        "sha256_in_prefix": "d28aca83b50c0dfedf9ee350bd130e73e105f4400ffc94d09e4e26b4681b5b9d",
+        "size_in_bytes": 241
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/test_pkg_resources.py",
+        "path_type": "hardlink",
+        "sha256": "50c8054c117c58dfb204e69672c98a96bd70a84cfb72ed81f4e9cf79732690c2",
+        "sha256_in_prefix": "50c8054c117c58dfb204e69672c98a96bd70a84cfb72ed81f4e9cf79732690c2",
+        "size_in_bytes": 15207
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/test_resources.py",
+        "path_type": "hardlink",
+        "sha256": "2b42ea300506a5143da546fd2b4bf223b19eb2fb6542f4c7d3be26f84d95425a",
+        "sha256_in_prefix": "2b42ea300506a5143da546fd2b4bf223b19eb2fb6542f4c7d3be26f84d95425a",
+        "size_in_bytes": 31252
+      },
+      {
+        "_path": "Lib/site-packages/pkg_resources/tests/test_working_set.py",
+        "path_type": "hardlink",
+        "sha256": "65427c4aee3bbf561f44391ff01ea704f1dc742855773811731a691d3c09b3d9",
+        "sha256_in_prefix": "65427c4aee3bbf561f44391ff01ea704f1dc742855773811731a691d3c09b3d9",
+        "size_in_bytes": 8539
+      },
+      {
+        "_path": "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/PKG-INFO",
+        "path_type": "hardlink",
+        "sha256": "134bcab7a060628587e9253886abd43ef6319a069a5e8ca62e998bb8463425cd",
+        "sha256_in_prefix": "134bcab7a060628587e9253886abd43ef6319a069a5e8ca62e998bb8463425cd",
+        "size_in_bytes": 6812
+      },
+      {
+        "_path": "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/SOURCES.txt",
+        "path_type": "hardlink",
+        "sha256": "970b9f3b051f0faea3698b003c438cc13e98e16c4969da6f65653d2502763dc4",
+        "sha256_in_prefix": "970b9f3b051f0faea3698b003c438cc13e98e16c4969da6f65653d2502763dc4",
+        "size_in_bytes": 23773
+      },
+      {
+        "_path": "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/dependency_links.txt",
+        "path_type": "hardlink",
+        "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+        "sha256_in_prefix": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+        "size_in_bytes": 1
+      },
+      {
+        "_path": "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/entry_points.txt",
+        "path_type": "hardlink",
+        "sha256": "ce482d8697ff15af4d544f69e85293dd793d0d1d5f680711538728820b15ee30",
+        "sha256_in_prefix": "ce482d8697ff15af4d544f69e85293dd793d0d1d5f680711538728820b15ee30",
+        "size_in_bytes": 2449
+      },
+      {
+        "_path": "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/requires.txt",
+        "path_type": "hardlink",
+        "sha256": "16b1af3f936778ac0ed4d4a41aad8eba95c4fcadaa7085e9542ea6b10d1d3e7c",
+        "sha256_in_prefix": "16b1af3f936778ac0ed4d4a41aad8eba95c4fcadaa7085e9542ea6b10d1d3e7c",
+        "size_in_bytes": 1260
+      },
+      {
+        "_path": "Lib/site-packages/setuptools-75.8.0-py3.9.egg-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "77dc8bdfdbff5bbaa62830d21fab13e1b1348ff2ecd4cdcfd7ad4e1a076c9b88",
+        "sha256_in_prefix": "77dc8bdfdbff5bbaa62830d21fab13e1b1348ff2ecd4cdcfd7ad4e1a076c9b88",
+        "size_in_bytes": 41
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "010b0c791156cfd090f5a06d71291b0780e7f2ddb0f3af863eb8a4969a008dec",
+        "sha256_in_prefix": "010b0c791156cfd090f5a06d71291b0780e7f2ddb0f3af863eb8a4969a008dec",
+        "size_in_bytes": 10406
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de77bdc4ef814a1995ff54e1de81b84e1a8fee006a43ce9c867eb1d0b406d37f",
+        "sha256_in_prefix": "de77bdc4ef814a1995ff54e1de81b84e1a8fee006a43ce9c867eb1d0b406d37f",
+        "size_in_bytes": 10944
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_core_metadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c8f97fa693a4ec47d53f7ed17fdc1c81abab5549cb2f8c2bf115a65420d3ded6",
+        "sha256_in_prefix": "c8f97fa693a4ec47d53f7ed17fdc1c81abab5549cb2f8c2bf115a65420d3ded6",
+        "size_in_bytes": 8797
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_entry_points.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "649a7945ec3fd279e2f8e31267a922daa3d2d9fb1b0d94f916b5e343099d74c2",
+        "sha256_in_prefix": "649a7945ec3fd279e2f8e31267a922daa3d2d9fb1b0d94f916b5e343099d74c2",
+        "size_in_bytes": 3204
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_imp.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "beb92130b6af6f5ac77ab2bdcc2b2b360847afd8bff0be9c3cf698ecd19d9159",
+        "sha256_in_prefix": "beb92130b6af6f5ac77ab2bdcc2b2b360847afd8bff0be9c3cf698ecd19d9159",
+        "size_in_bytes": 2063
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_importlib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f55a58b9ad11b92c29d292404ae54835cbc2b2e9000e43cce29ec1a753820726",
+        "sha256_in_prefix": "f55a58b9ad11b92c29d292404ae54835cbc2b2e9000e43cce29ec1a753820726",
+        "size_in_bytes": 308
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_itertools.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c564e44fc4ca19ef837902bedaf5d3f3d0884ed0ffbf72c8dfd4fc2c0a174f35",
+        "sha256_in_prefix": "c564e44fc4ca19ef837902bedaf5d3f3d0884ed0ffbf72c8dfd4fc2c0a174f35",
+        "size_in_bytes": 841
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_normalization.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a10ae35aeb6490e787499dd858fdeb7f1be19ec10e636dca87d07d5962894ee7",
+        "sha256_in_prefix": "a10ae35aeb6490e787499dd858fdeb7f1be19ec10e636dca87d07d5962894ee7",
+        "size_in_bytes": 4637
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_path.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "88189afc62ceae60425ad0c6a75fc0585972c440988252eb176f742d4b43298a",
+        "sha256_in_prefix": "88189afc62ceae60425ad0c6a75fc0585972c440988252eb176f742d4b43298a",
+        "size_in_bytes": 2837
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_reqs.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "97326f4ea57d989b317d44c7563fcb997e40e98ac4b570fed11652008a744c2c",
+        "sha256_in_prefix": "97326f4ea57d989b317d44c7563fcb997e40e98ac4b570fed11652008a744c2c",
+        "size_in_bytes": 1580
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_shutil.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1b1d1ea3b21b50911b6e78befaca655b262106f173019623c5592c426207857b",
+        "sha256_in_prefix": "1b1d1ea3b21b50911b6e78befaca655b262106f173019623c5592c426207857b",
+        "size_in_bytes": 1678
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/_static.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "992d934b489cf528d617095fc7ef9ce599f359444d8515b83dda94fc24060937",
+        "sha256_in_prefix": "992d934b489cf528d617095fc7ef9ce599f359444d8515b83dda94fc24060937",
+        "size_in_bytes": 5182
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/archive_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fa8486543e82b4a7758ceecfee2334f50843f5ffda69ae29415323b4d3592cc1",
+        "sha256_in_prefix": "fa8486543e82b4a7758ceecfee2334f50843f5ffda69ae29415323b4d3592cc1",
+        "size_in_bytes": 6136
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/build_meta.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d8a35b28506587f4fa3b9210ba03b26744fea2030963493128d02da814733fbf",
+        "sha256_in_prefix": "d8a35b28506587f4fa3b9210ba03b26744fea2030963493128d02da814733fbf",
+        "size_in_bytes": 18115
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/depends.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c9c42fefafd5ea49066cd5dd9ef70e35b350245ec085b8452891afa9b8093c5d",
+        "sha256_in_prefix": "c9c42fefafd5ea49066cd5dd9ef70e35b350245ec085b8452891afa9b8093c5d",
+        "size_in_bytes": 5327
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/discovery.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8634ab29a6db9e84f09e3cc8719f8f281457d14c6188fc75c4cdf5b2466b10bd",
+        "sha256_in_prefix": "8634ab29a6db9e84f09e3cc8719f8f281457d14c6188fc75c4cdf5b2466b10bd",
+        "size_in_bytes": 20766
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/dist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1c27e45ed0f12089e87164a06bf87c6a2dc0e69ab52fbe69f543fc3a1f9c135f",
+        "sha256_in_prefix": "1c27e45ed0f12089e87164a06bf87c6a2dc0e69ab52fbe69f543fc3a1f9c135f",
+        "size_in_bytes": 32608
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/errors.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "06c101344875f5d4d0560bc5a0fab1426b67829757d9de01be9bb6013ef3be57",
+        "sha256_in_prefix": "06c101344875f5d4d0560bc5a0fab1426b67829757d9de01be9bb6013ef3be57",
+        "size_in_bytes": 2880
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/extension.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7cd8a3ce3e2150193060575666c70c5aa4f6692460ba2dd320e2475122622110",
+        "sha256_in_prefix": "7cd8a3ce3e2150193060575666c70c5aa4f6692460ba2dd320e2475122622110",
+        "size_in_bytes": 6232
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/glob.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bbaf4bccd514384601604f5a541418d8550fbcddf4b418d9df52f2fbd8a9f1d2",
+        "sha256_in_prefix": "bbaf4bccd514384601604f5a541418d8550fbcddf4b418d9df52f2fbd8a9f1d2",
+        "size_in_bytes": 4867
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/installer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "78c86a61245dbb159b706a56ebcd71caca9fd802ecfd438eeabe1d9315ce4201",
+        "sha256_in_prefix": "78c86a61245dbb159b706a56ebcd71caca9fd802ecfd438eeabe1d9315ce4201",
+        "size_in_bytes": 4128
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/launch.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ff4e1d0907e6bddccf2520e3c9200aa893e4b23adfb1ed5f158473bdb48e654d",
+        "sha256_in_prefix": "ff4e1d0907e6bddccf2520e3c9200aa893e4b23adfb1ed5f158473bdb48e654d",
+        "size_in_bytes": 868
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/logging.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b4c742cfabec06b12103bc38938e73830a1cfa8263cb0c992741bb024519cf73",
+        "sha256_in_prefix": "b4c742cfabec06b12103bc38938e73830a1cfa8263cb0c992741bb024519cf73",
+        "size_in_bytes": 1254
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/modified.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "923e3ee42779a890415b72291aa0d12e3b7a03686cbbf91f613d4c1052789e9a",
+        "sha256_in_prefix": "923e3ee42779a890415b72291aa0d12e3b7a03686cbbf91f613d4c1052789e9a",
+        "size_in_bytes": 393
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/monkey.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4001bcddf317fe2a5e467f85fa1757de611d226099af6156fc9b449de8cde78f",
+        "sha256_in_prefix": "4001bcddf317fe2a5e467f85fa1757de611d226099af6156fc9b449de8cde78f",
+        "size_in_bytes": 3534
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/msvc.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2705e939e05111d9955310b858d79159bf03762604ae2558f43e1cb48b95992c",
+        "sha256_in_prefix": "2705e939e05111d9955310b858d79159bf03762604ae2558f43e1cb48b95992c",
+        "size_in_bytes": 36341
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/namespaces.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a283173798d0e40d5ef770ee9b25d4a6f3286218169f6d150ef490200f686801",
+        "sha256_in_prefix": "a283173798d0e40d5ef770ee9b25d4a6f3286218169f6d150ef490200f686801",
+        "size_in_bytes": 3693
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/package_index.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "37b09e225165cbaefabf2e07f546137efbe6ce9f47886c9a9de80afc6858a02b",
+        "sha256_in_prefix": "37b09e225165cbaefabf2e07f546137efbe6ce9f47886c9a9de80afc6858a02b",
+        "size_in_bytes": 33496
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/sandbox.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "078521b6cbbe3789030330de509fa0acd3f446eb15a56404a7c2846140fc8e86",
+        "sha256_in_prefix": "078521b6cbbe3789030330de509fa0acd3f446eb15a56404a7c2846140fc8e86",
+        "size_in_bytes": 16173
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/unicode_utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fd0338f537bc49d9d3f6196fbd6559a15404eaeecf7eb8161fd9a01017ae052c",
+        "sha256_in_prefix": "fd0338f537bc49d9d3f6196fbd6559a15404eaeecf7eb8161fd9a01017ae052c",
+        "size_in_bytes": 3129
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0472329afe746d59dd7d1d762e4833f3f94518a385e7462046122e3ac6ffcdfd",
+        "sha256_in_prefix": "0472329afe746d59dd7d1d762e4833f3f94518a385e7462046122e3ac6ffcdfd",
+        "size_in_bytes": 284
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/warnings.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "472c38d315d01691b84e1e981624628b8d99b86985964ecd2788f64280ff2fad",
+        "sha256_in_prefix": "472c38d315d01691b84e1e981624628b8d99b86985964ecd2788f64280ff2fad",
+        "size_in_bytes": 3869
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6136209eb244ace107b2b8f6b64ad512e8aa43f064e94839268c62cfeb58e7e4",
+        "sha256_in_prefix": "6136209eb244ace107b2b8f6b64ad512e8aa43f064e94839268c62cfeb58e7e4",
+        "size_in_bytes": 7689
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/__pycache__/windows_support.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2760391661f51acacff78a87aff2859b2006121bae48ffd68deb94ee9b997bb9",
+        "sha256_in_prefix": "2760391661f51acacff78a87aff2859b2006121bae48ffd68deb94ee9b997bb9",
+        "size_in_bytes": 996
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_core_metadata.py",
+        "path_type": "hardlink",
+        "sha256": "dfc90134dc417b5490010f96b671fd732a3b47f60d378ec0750a9dd0e4f422ea",
+        "sha256_in_prefix": "dfc90134dc417b5490010f96b671fd732a3b47f60d378ec0750a9dd0e4f422ea",
+        "size_in_bytes": 11070
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "c4662e856c0b1b4ec9d10e3d0559c48cfcbac320dc77abde24c0c95fb9639723",
+        "sha256_in_prefix": "c4662e856c0b1b4ec9d10e3d0559c48cfcbac320dc77abde24c0c95fb9639723",
+        "size_in_bytes": 359
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3aae62356ae95b3045d94b7e29a74ada7bcf91fcc9d44ca6e9a7abbdde6cdd55",
+        "sha256_in_prefix": "3aae62356ae95b3045d94b7e29a74ada7bcf91fcc9d44ca6e9a7abbdde6cdd55",
+        "size_in_bytes": 330
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/_log.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e0b638deb1e80a442c5ac20ced445a58a1d20abd591c009364d1870e42dcd0f1",
+        "sha256_in_prefix": "e0b638deb1e80a442c5ac20ced445a58a1d20abd591c009364d1870e42dcd0f1",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/_macos_compat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "86ee749cb679e82facc603d9b48feb0f09e88c681b66716d3e33beb6937589ce",
+        "sha256_in_prefix": "86ee749cb679e82facc603d9b48feb0f09e88c681b66716d3e33beb6937589ce",
+        "size_in_bytes": 404
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/_modified.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "91ffd81aeca9eb3ec66173bab7d9e2b21bd702bd65f23290c7d0c008b3bad22a",
+        "sha256_in_prefix": "91ffd81aeca9eb3ec66173bab7d9e2b21bd702bd65f23290c7d0c008b3bad22a",
+        "size_in_bytes": 2929
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/_msvccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8f057aad6418bcf447a4ff2091046d8522d03bd85ac3d55490b784811e810b45",
+        "sha256_in_prefix": "8f057aad6418bcf447a4ff2091046d8522d03bd85ac3d55490b784811e810b45",
+        "size_in_bytes": 14702
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/archive_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "011ef3711736c83e8884511675897951791cff85859c0960a9d4f5a58a748ec1",
+        "sha256_in_prefix": "011ef3711736c83e8884511675897951791cff85859c0960a9d4f5a58a748ec1",
+        "size_in_bytes": 6153
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/ccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8458aab166504aab4fb897f4307c5a59df2010e6f3ce2bd6ec2fe956981f3c1d",
+        "sha256_in_prefix": "8458aab166504aab4fb897f4307c5a59df2010e6f3ce2bd6ec2fe956981f3c1d",
+        "size_in_bytes": 36034
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/cmd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f57849b1062e03e3b3e096b05c44ff8f10c0e3a668989b32ae8ed04894606750",
+        "sha256_in_prefix": "f57849b1062e03e3b3e096b05c44ff8f10c0e3a668989b32ae8ed04894606750",
+        "size_in_bytes": 14604
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/core.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de97e1c5fd84f256e22ee8be2c4322a21ea1aa7243f3579aab3d1192ebae759f",
+        "sha256_in_prefix": "de97e1c5fd84f256e22ee8be2c4322a21ea1aa7243f3579aab3d1192ebae759f",
+        "size_in_bytes": 7213
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/cygwinccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "009a52b98c3c89ec678162773f060071558ffb54a96eeb8c0583aa3d3c56a96d",
+        "sha256_in_prefix": "009a52b98c3c89ec678162773f060071558ffb54a96eeb8c0583aa3d3c56a96d",
+        "size_in_bytes": 8109
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/debug.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ad042db6ebd5def833fcd57a6102ad85dd0e0b04796557a2d312307fcad9f19c",
+        "sha256_in_prefix": "ad042db6ebd5def833fcd57a6102ad85dd0e0b04796557a2d312307fcad9f19c",
+        "size_in_bytes": 205
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/dep_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a37532890ff741df682b1b83a92c5fafbf66d64dbc1baff88f24217132f2d66e",
+        "sha256_in_prefix": "a37532890ff741df682b1b83a92c5fafbf66d64dbc1baff88f24217132f2d66e",
+        "size_in_bytes": 541
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/dir_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "32070e158076922e16b367329beb29255d146044c2b8f5103dacdf53cd284373",
+        "sha256_in_prefix": "32070e158076922e16b367329beb29255d146044c2b8f5103dacdf53cd284373",
+        "size_in_bytes": 7191
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/dist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a3f32a33761a3e01b745a4cedd838b17f9fd59cdcc2325c63caa7da14d9aeed8",
+        "sha256_in_prefix": "a3f32a33761a3e01b745a4cedd838b17f9fd59cdcc2325c63caa7da14d9aeed8",
+        "size_in_bytes": 36959
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/errors.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1061c5a2f1e13c7fcc0c9b3b678ee6fe01c79b9c287c87ebf8997321eab76ac2",
+        "sha256_in_prefix": "1061c5a2f1e13c7fcc0c9b3b678ee6fe01c79b9c287c87ebf8997321eab76ac2",
+        "size_in_bytes": 4994
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/extension.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5b65fd6301d6368d5807aaa35b35b163e1c8e65c3c8ba60deac2aadcc4cdfc51",
+        "sha256_in_prefix": "5b65fd6301d6368d5807aaa35b35b163e1c8e65c3c8ba60deac2aadcc4cdfc51",
+        "size_in_bytes": 7147
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/fancy_getopt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0c014c67d6bc314718378660f89cb75c4f485eeec78693f89015d940d3f85c5a",
+        "sha256_in_prefix": "0c014c67d6bc314718378660f89cb75c4f485eeec78693f89015d940d3f85c5a",
+        "size_in_bytes": 10885
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/file_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f3fd0fe4254fe5b75a6c91ce9d871251a9a98e27bdb05a9c950faedf10ad195c",
+        "sha256_in_prefix": "f3fd0fe4254fe5b75a6c91ce9d871251a9a98e27bdb05a9c950faedf10ad195c",
+        "size_in_bytes": 6046
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/filelist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b73b1dcd1421cbfa8cd990eabffc3c32c616b15462d3d1f5b959ddafec7e870c",
+        "sha256_in_prefix": "b73b1dcd1421cbfa8cd990eabffc3c32c616b15462d3d1f5b959ddafec7e870c",
+        "size_in_bytes": 10734
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/log.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "196c05f8bf7c19317b2a354a856581d921658a2af9e0d0572e28c4946e52240c",
+        "sha256_in_prefix": "196c05f8bf7c19317b2a354a856581d921658a2af9e0d0572e28c4946e52240c",
+        "size_in_bytes": 1640
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/spawn.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2947ce03432c382ea8819adbd463765199c4c36bca5cd3350129b3db5cedc7fb",
+        "sha256_in_prefix": "2947ce03432c382ea8819adbd463765199c4c36bca5cd3350129b3db5cedc7fb",
+        "size_in_bytes": 3446
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/sysconfig.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "79bb5e7d84a41ca963e694cc94d3d47127a1a05087b3e5a6943f6b37a57391b3",
+        "sha256_in_prefix": "79bb5e7d84a41ca963e694cc94d3d47127a1a05087b3e5a6943f6b37a57391b3",
+        "size_in_bytes": 14476
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/text_file.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "affbbd7fc1c892c84af6321b54dbed53eecef22145cf4b4fa5f1e6424ceb336f",
+        "sha256_in_prefix": "affbbd7fc1c892c84af6321b54dbed53eecef22145cf4b4fa5f1e6424ceb336f",
+        "size_in_bytes": 8254
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/unixccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eb51f0dc31fdfc92fa0a7a15b88a5e5099c04cb7fd092fe4f4c719f6e5771e06",
+        "sha256_in_prefix": "eb51f0dc31fdfc92fa0a7a15b88a5e5099c04cb7fd092fe4f4c719f6e5771e06",
+        "size_in_bytes": 10275
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fcd63710a5df3f091baee0eef217d9a624b175fed781d88908b05f8703eef7b7",
+        "sha256_in_prefix": "fcd63710a5df3f091baee0eef217d9a624b175fed781d88908b05f8703eef7b7",
+        "size_in_bytes": 13391
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "858528e8a20d7e887d93c6678fb3ded5a2f43b2bade105500520437503f7e19a",
+        "sha256_in_prefix": "858528e8a20d7e887d93c6678fb3ded5a2f43b2bade105500520437503f7e19a",
+        "size_in_bytes": 8092
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/versionpredicate.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d01388b225d3710006b1de997ad3d649d696a6bd8453590e825565d0531bc641",
+        "sha256_in_prefix": "d01388b225d3710006b1de997ad3d649d696a6bd8453590e825565d0531bc641",
+        "size_in_bytes": 5232
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/__pycache__/zosccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e2696f1df59a4c13b4c3471f423c59acfc429c9e0340ab58f7168322a0b49676",
+        "sha256_in_prefix": "e2696f1df59a4c13b4c3471f423c59acfc429c9e0340ab58f7168322a0b49676",
+        "size_in_bytes": 4212
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/_log.py",
+        "path_type": "hardlink",
+        "sha256": "8be94d4d37174bc4e65884c9e833831afb56e73e6d31ab6d250efa87cad9c505",
+        "sha256_in_prefix": "8be94d4d37174bc4e65884c9e833831afb56e73e6d31ab6d250efa87cad9c505",
+        "size_in_bytes": 42
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/_macos_compat.py",
+        "path_type": "hardlink",
+        "sha256": "273506845e04e722084c76d468fa1b6445a318776badc355eb7cfce92e118c17",
+        "sha256_in_prefix": "273506845e04e722084c76d468fa1b6445a318776badc355eb7cfce92e118c17",
+        "size_in_bytes": 239
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/_modified.py",
+        "path_type": "hardlink",
+        "sha256": "259bc850a1e27673bfc9d74e692f68697752ad69f240c89f6ad68092fa6c9c85",
+        "sha256_in_prefix": "259bc850a1e27673bfc9d74e692f68697752ad69f240c89f6ad68092fa6c9c85",
+        "size_in_bytes": 2446
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/_msvccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "e045f2facc92015955ba273207a0b6dacf030b4f57e89d9dd677f729f275e391",
+        "sha256_in_prefix": "e045f2facc92015955ba273207a0b6dacf030b4f57e89d9dd677f729f275e391",
+        "size_in_bytes": 21195
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/archive_util.py",
+        "path_type": "hardlink",
+        "sha256": "d798c76cb9820dc9d9ef9276b451720a608feb2176696133573fa5bac69ecabe",
+        "sha256_in_prefix": "d798c76cb9820dc9d9ef9276b451720a608feb2176696133573fa5bac69ecabe",
+        "size_in_bytes": 7844
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/ccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "38acf0316edfd394d15c0113b0a837e0f5757f7b116c69808f58f5eb9d0907e1",
+        "sha256_in_prefix": "38acf0316edfd394d15c0113b0a837e0f5757f7b116c69808f58f5eb9d0907e1",
+        "size_in_bytes": 49190
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/cmd.py",
+        "path_type": "hardlink",
+        "sha256": "fcb4cb73078d02c0a62af50907d147e200ad779f7f779f57d0c24b1e5c0e6ee1",
+        "sha256_in_prefix": "fcb4cb73078d02c0a62af50907d147e200ad779f7f779f57d0c24b1e5c0e6ee1",
+        "size_in_bytes": 18668
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "19f140cdb06a935ab1487e0175a2a2a0a4b88514670f8e01026c0437ce42e2ef",
+        "sha256_in_prefix": "19f140cdb06a935ab1487e0175a2a2a0a4b88514670f8e01026c0437ce42e2ef",
+        "size_in_bytes": 386
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6677e0707da0c357f49ac7b14a34391ff120ad3aee27b7405179566bec414785",
+        "sha256_in_prefix": "6677e0707da0c357f49ac7b14a34391ff120ad3aee27b7405179566bec414785",
+        "size_in_bytes": 451
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/_framework_compat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "06c35422014c15756211308b64c2bce30cd737de27d679c648df66dafb7b4a8b",
+        "sha256_in_prefix": "06c35422014c15756211308b64c2bce30cd737de27d679c648df66dafb7b4a8b",
+        "size_in_bytes": 1872
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/bdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c5b1298004e1c8d831bc2458730f9039eae0ad33ed927efa8777f01c08bd8f88",
+        "sha256_in_prefix": "c5b1298004e1c8d831bc2458730f9039eae0ad33ed927efa8777f01c08bd8f88",
+        "size_in_bytes": 4149
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "358510ac114463349573a2dd8a3fc118fe250760fce028473ad3861921d774bb",
+        "sha256_in_prefix": "358510ac114463349573a2dd8a3fc118fe250760fce028473ad3861921d774bb",
+        "size_in_bytes": 3548
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e88adee05925d526551c8639e4dda2f45db41971263783c7e812beb79f36e08a",
+        "sha256_in_prefix": "e88adee05925d526551c8639e4dda2f45db41971263783c7e812beb79f36e08a",
+        "size_in_bytes": 12222
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/build.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "52d01f0cea9463101b99946cace0fbc99d5f354cfc51afa75595def77cac0335",
+        "sha256_in_prefix": "52d01f0cea9463101b99946cace0fbc99d5f354cfc51afa75595def77cac0335",
+        "size_in_bytes": 3953
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/build_clib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "86d9606f96f2a03a7c62386601a3b00e6779ec3f69d8f70218f9c43dbf98d113",
+        "sha256_in_prefix": "86d9606f96f2a03a7c62386601a3b00e6779ec3f69d8f70218f9c43dbf98d113",
+        "size_in_bytes": 4900
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/build_ext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d4e4c6171a72a887864936623dbbbcc09646ea7dcbcf7a1143c643333d5a87d",
+        "sha256_in_prefix": "2d4e4c6171a72a887864936623dbbbcc09646ea7dcbcf7a1143c643333d5a87d",
+        "size_in_bytes": 16829
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/build_py.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f283a3ea7b913c9bfe75d78ad718d6fdc2d983b6954c8118fb0b3b3906ce2e12",
+        "sha256_in_prefix": "f283a3ea7b913c9bfe75d78ad718d6fdc2d983b6954c8118fb0b3b3906ce2e12",
+        "size_in_bytes": 9720
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/build_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5efd5261222f1e828d8dcf73addb9d9a58d142097840edb75d5a2cabe630215e",
+        "sha256_in_prefix": "5efd5261222f1e828d8dcf73addb9d9a58d142097840edb75d5a2cabe630215e",
+        "size_in_bytes": 4634
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/check.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "33c01306fe3144ba565ba4b04764fc8431da6d1a9aeac5b8f40d0a7e38a0546d",
+        "sha256_in_prefix": "33c01306fe3144ba565ba4b04764fc8431da6d1a9aeac5b8f40d0a7e38a0546d",
+        "size_in_bytes": 4808
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/clean.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f0e098a4646984a77d990680e2233885be72b4959bf65d79a96162dd78fa7727",
+        "sha256_in_prefix": "f0e098a4646984a77d990680e2233885be72b4959bf65d79a96162dd78fa7727",
+        "size_in_bytes": 2068
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/config.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f261f403f7c849184b9eabf0c2aaebb767c8ab151da247d4baa9d9b3c7332c3f",
+        "sha256_in_prefix": "f261f403f7c849184b9eabf0c2aaebb767c8ab151da247d4baa9d9b3c7332c3f",
+        "size_in_bytes": 10485
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1102972f03d13d1778790079aec03cfb094f0dff0093d7f22583a8f44f37f0fe",
+        "sha256_in_prefix": "1102972f03d13d1778790079aec03cfb094f0dff0093d7f22583a8f44f37f0fe",
+        "size_in_bytes": 17096
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_data.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "867a14fab6dbef9e29a027d5a8384a3522d3dc62e9970b219b9a23dd5381f562",
+        "sha256_in_prefix": "867a14fab6dbef9e29a027d5a8384a3522d3dc62e9970b219b9a23dd5381f562",
+        "size_in_bytes": 2847
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_egg_info.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "34dfa702b571071893c678bb7ee5ea21808821df601fb85a7f440494458b5dcf",
+        "sha256_in_prefix": "34dfa702b571071893c678bb7ee5ea21808821df601fb85a7f440494458b5dcf",
+        "size_in_bytes": 3407
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_headers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ac09428da24d2e39587f195a08a1d17b1424bc07a90603cfe6663e416dc64267",
+        "sha256_in_prefix": "ac09428da24d2e39587f195a08a1d17b1424bc07a90603cfe6663e416dc64267",
+        "size_in_bytes": 1820
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_lib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "295c6b7a437574f53fbe289b66b6a3e59d84a035ec17ad2a24283784dff5e2ad",
+        "sha256_in_prefix": "295c6b7a437574f53fbe289b66b6a3e59d84a035ec17ad2a24283784dff5e2ad",
+        "size_in_bytes": 5206
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/install_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a1efc6365e95d700db3a65f981d1c79ad3b54a8fe18b9e4570c3d8f78e17def7",
+        "sha256_in_prefix": "a1efc6365e95d700db3a65f981d1c79ad3b54a8fe18b9e4570c3d8f78e17def7",
+        "size_in_bytes": 2140
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/__pycache__/sdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e34af5346ba062c0bc82a14d5253dedcaad845c0177fab7878173e9a1f7793fe",
+        "sha256_in_prefix": "e34af5346ba062c0bc82a14d5253dedcaad845c0177fab7878173e9a1f7793fe",
+        "size_in_bytes": 14484
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/_framework_compat.py",
+        "path_type": "hardlink",
+        "sha256": "d2265d4896331915820afcd10ca13e474fbfc9a018bc531dd729576f67985ee8",
+        "sha256_in_prefix": "d2265d4896331915820afcd10ca13e474fbfc9a018bc531dd729576f67985ee8",
+        "size_in_bytes": 1609
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/bdist.py",
+        "path_type": "hardlink",
+        "sha256": "bad80254deb1214bc0140adcfd9fcee531375f81b4d028ab878e909c539aa280",
+        "sha256_in_prefix": "bad80254deb1214bc0140adcfd9fcee531375f81b4d028ab878e909c539aa280",
+        "size_in_bytes": 5423
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/bdist_dumb.py",
+        "path_type": "hardlink",
+        "sha256": "1a2fddd4dcf897a1b3ff15382d17d1551281ae2db65a834f33bb98c97da4b1d9",
+        "sha256_in_prefix": "1a2fddd4dcf897a1b3ff15382d17d1551281ae2db65a834f33bb98c97da4b1d9",
+        "size_in_bytes": 4582
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/bdist_rpm.py",
+        "path_type": "hardlink",
+        "sha256": "0df660bcf9a6dcf4c0777f58ccb790f1f99bc9119a5e8fa79a7533604b5c720d",
+        "sha256_in_prefix": "0df660bcf9a6dcf4c0777f58ccb790f1f99bc9119a5e8fa79a7533604b5c720d",
+        "size_in_bytes": 21686
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/build.py",
+        "path_type": "hardlink",
+        "sha256": "89b6f008474d6d725294359fd3546deb0442b04dc59b0aa2cc6a9ff642e72f92",
+        "sha256_in_prefix": "89b6f008474d6d725294359fd3546deb0442b04dc59b0aa2cc6a9ff642e72f92",
+        "size_in_bytes": 5768
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/build_clib.py",
+        "path_type": "hardlink",
+        "sha256": "30027e4993aa9f486fcb44e721b468cdb7a20d38870b32c61af0892b0db50eef",
+        "sha256_in_prefix": "30027e4993aa9f486fcb44e721b468cdb7a20d38870b32c61af0892b0db50eef",
+        "size_in_bytes": 7727
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/build_ext.py",
+        "path_type": "hardlink",
+        "sha256": "2ca2eb10ba08c361d3936fc510156ab980bbadfa85ce332669648551010d6b45",
+        "sha256_in_prefix": "2ca2eb10ba08c361d3936fc510156ab980bbadfa85ce332669648551010d6b45",
+        "size_in_bytes": 32048
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/build_py.py",
+        "path_type": "hardlink",
+        "sha256": "70d7bcbf0321c8f27680dea3a2df5c398e4eb943d4bd3ea3f5f205702f857229",
+        "sha256_in_prefix": "70d7bcbf0321c8f27680dea3a2df5c398e4eb943d4bd3ea3f5f205702f857229",
+        "size_in_bytes": 16552
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/build_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "775425bff6774f6744c0fde7bceef111e5635c5fd54e7fc95aa1baf13a426b6d",
+        "sha256_in_prefix": "775425bff6774f6744c0fde7bceef111e5635c5fd54e7fc95aa1baf13a426b6d",
+        "size_in_bytes": 5600
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/check.py",
+        "path_type": "hardlink",
+        "sha256": "a625fe8c7c91e92d6d7b618a3b5abe8275b715ea8cea633283cb309c75ab36d4",
+        "sha256_in_prefix": "a625fe8c7c91e92d6d7b618a3b5abe8275b715ea8cea633283cb309c75ab36d4",
+        "size_in_bytes": 4912
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/clean.py",
+        "path_type": "hardlink",
+        "sha256": "aa52ad87be2358b66329ada7c4e6b2ff616e6ba315353ae80296903af6b67707",
+        "sha256_in_prefix": "aa52ad87be2358b66329ada7c4e6b2ff616e6ba315353ae80296903af6b67707",
+        "size_in_bytes": 2595
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/config.py",
+        "path_type": "hardlink",
+        "sha256": "14a776bd44953a9d2ba5551eaf86e3e83f78f9fcb1c85f072718ad46564573d7",
+        "sha256_in_prefix": "14a776bd44953a9d2ba5551eaf86e3e83f78f9fcb1c85f072718ad46564573d7",
+        "size_in_bytes": 13008
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/install.py",
+        "path_type": "hardlink",
+        "sha256": "9974f09e1a3d7b8918202288e7e642e2b57b253d1ce8cf02f2355801fa1f785d",
+        "sha256_in_prefix": "9974f09e1a3d7b8918202288e7e642e2b57b253d1ce8cf02f2355801fa1f785d",
+        "size_in_bytes": 30122
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/install_data.py",
+        "path_type": "hardlink",
+        "sha256": "4dc5859587793500de7ea89056790b3de14fd27d5b7b17e1e880ecf24f475d30",
+        "sha256_in_prefix": "4dc5859587793500de7ea89056790b3de14fd27d5b7b17e1e880ecf24f475d30",
+        "size_in_bytes": 2810
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/install_egg_info.py",
+        "path_type": "hardlink",
+        "sha256": "7df88ba14d62bd027cab6fd62fb6728196d470eb207452ca2fba2d1082565a42",
+        "sha256_in_prefix": "7df88ba14d62bd027cab6fd62fb6728196d470eb207452ca2fba2d1082565a42",
+        "size_in_bytes": 2868
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/install_headers.py",
+        "path_type": "hardlink",
+        "sha256": "d5016e91e009c52b5c93c747889cdeea9e170924eeb4194f108311e6fcca972e",
+        "sha256_in_prefix": "d5016e91e009c52b5c93c747889cdeea9e170924eeb4194f108311e6fcca972e",
+        "size_in_bytes": 1251
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/install_lib.py",
+        "path_type": "hardlink",
+        "sha256": "a4a2cd135ae7a9da12a3c6eaf5e7d06d0b90a6b8394c6b30169bca91ad45dc58",
+        "sha256_in_prefix": "a4a2cd135ae7a9da12a3c6eaf5e7d06d0b90a6b8394c6b30169bca91ad45dc58",
+        "size_in_bytes": 8330
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/install_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "430f0aac2db899c21e244bdc04d28848ca62ef99e94a6ea3cd6e813b303d1bb8",
+        "sha256_in_prefix": "430f0aac2db899c21e244bdc04d28848ca62ef99e94a6ea3cd6e813b303d1bb8",
+        "size_in_bytes": 1937
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/command/sdist.py",
+        "path_type": "hardlink",
+        "sha256": "14d4b3edc448e10d6fee80c7a1503104029da3283a6991dd6076b6e53ac79b6e",
+        "sha256_in_prefix": "14d4b3edc448e10d6fee80c7a1503104029da3283a6991dd6076b6e53ac79b6e",
+        "size_in_bytes": 18837
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/compat/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "b40d2bcfea679742cf326789abbc8b94cc0a04cbf02be1699c8c2589890afa21",
+        "sha256_in_prefix": "b40d2bcfea679742cf326789abbc8b94cc0a04cbf02be1699c8c2589890afa21",
+        "size_in_bytes": 396
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/compat/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "072c7a7a77ae18e5ba28264faf84dd844ce7d64ff2fa9e628ef3470c60dc0550",
+        "sha256_in_prefix": "072c7a7a77ae18e5ba28264faf84dd844ce7d64ff2fa9e628ef3470c60dc0550",
+        "size_in_bytes": 841
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/compat/__pycache__/py39.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f70be21fbbeae86e80b065de2687aa94877cfccbf50153aedf9c6f39b6899bb9",
+        "sha256_in_prefix": "f70be21fbbeae86e80b065de2687aa94877cfccbf50153aedf9c6f39b6899bb9",
+        "size_in_bytes": 1865
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/compat/py39.py",
+        "path_type": "hardlink",
+        "sha256": "84eb03ea5c192ea66832769c349dcfea7500f8b250844a55b584f3547d28f7a3",
+        "sha256_in_prefix": "84eb03ea5c192ea66832769c349dcfea7500f8b250844a55b584f3547d28f7a3",
+        "size_in_bytes": 1964
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/core.py",
+        "path_type": "hardlink",
+        "sha256": "1841ca6850b8f13de8fbf4a61f8f3ae06bcacb1d4881b542e884883d5971edae",
+        "sha256_in_prefix": "1841ca6850b8f13de8fbf4a61f8f3ae06bcacb1d4881b542e884883d5971edae",
+        "size_in_bytes": 9364
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/cygwinccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "d4b40ed29f80c0348dccb264fca3c82a9eb67a20e99066787cc32cd8dde8f78c",
+        "sha256_in_prefix": "d4b40ed29f80c0348dccb264fca3c82a9eb67a20e99066787cc32cd8dde8f78c",
+        "size_in_bytes": 11891
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/debug.py",
+        "path_type": "hardlink",
+        "sha256": "37a32b4c0a8aea5f52564ead5b0791d74f0f33c3a5eea3657f257e9c770b86c6",
+        "sha256_in_prefix": "37a32b4c0a8aea5f52564ead5b0791d74f0f33c3a5eea3657f257e9c770b86c6",
+        "size_in_bytes": 139
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/dep_util.py",
+        "path_type": "hardlink",
+        "sha256": "c4def9a7a6691e13221c473eae92f65e29494329c79c336269f1ed79a678b635",
+        "sha256_in_prefix": "c4def9a7a6691e13221c473eae92f65e29494329c79c336269f1ed79a678b635",
+        "size_in_bytes": 349
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/dir_util.py",
+        "path_type": "hardlink",
+        "sha256": "0d73d495f5551ac83d07e26083802dfe3f53eef33ad0e8303579101ea4e8efe2",
+        "sha256_in_prefix": "0d73d495f5551ac83d07e26083802dfe3f53eef33ad0e8303579101ea4e8efe2",
+        "size_in_bytes": 7236
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/dist.py",
+        "path_type": "hardlink",
+        "sha256": "f4d39a17b4f3df6b80f6d97548c9307b96dbf1833a844b68d353c6beea3eb835",
+        "sha256_in_prefix": "f4d39a17b4f3df6b80f6d97548c9307b96dbf1833a844b68d353c6beea3eb835",
+        "size_in_bytes": 51529
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/errors.py",
+        "path_type": "hardlink",
+        "sha256": "6d9ddc2f5629998547258120c3c50cf2f96c2cc2297805ea8ba203495f58aa1c",
+        "sha256_in_prefix": "6d9ddc2f5629998547258120c3c50cf2f96c2cc2297805ea8ba203495f58aa1c",
+        "size_in_bytes": 3325
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/extension.py",
+        "path_type": "hardlink",
+        "sha256": "37a1b288cb3fab13320e370e5ee2918842026f315c5576d80f70ee0fdfe10f99",
+        "sha256_in_prefix": "37a1b288cb3fab13320e370e5ee2918842026f315c5576d80f70ee0fdfe10f99",
+        "size_in_bytes": 10755
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/fancy_getopt.py",
+        "path_type": "hardlink",
+        "sha256": "3e374ef9b5825b48a657f50df8c184c3d47618fd8e884f291e32138264c06374",
+        "sha256_in_prefix": "3e374ef9b5825b48a657f50df8c184c3d47618fd8e884f291e32138264c06374",
+        "size_in_bytes": 17895
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/file_util.py",
+        "path_type": "hardlink",
+        "sha256": "60540bfe90f784bb8447d208fc7ebe8430bf608184a2891d778c1e74bba24d6d",
+        "sha256_in_prefix": "60540bfe90f784bb8447d208fc7ebe8430bf608184a2891d778c1e74bba24d6d",
+        "size_in_bytes": 7978
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/filelist.py",
+        "path_type": "hardlink",
+        "sha256": "0d7ddd5a70d3026124e5eed290661d5fa4491c50b36451fcaad226eea14069b1",
+        "sha256_in_prefix": "0d7ddd5a70d3026124e5eed290661d5fa4491c50b36451fcaad226eea14069b1",
+        "size_in_bytes": 13567
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/log.py",
+        "path_type": "hardlink",
+        "sha256": "57206ce63ef3e3e2ba5d310405385473d1f2329a0f2c6b50a4446a6f3e72970c",
+        "sha256_in_prefix": "57206ce63ef3e3e2ba5d310405385473d1f2329a0f2c6b50a4446a6f3e72970c",
+        "size_in_bytes": 1200
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/spawn.py",
+        "path_type": "hardlink",
+        "sha256": "902b440052603e94995dba33ad57ee07b078a2661486bfa12daba4a6e5c65d88",
+        "sha256_in_prefix": "902b440052603e94995dba33ad57ee07b078a2661486bfa12daba4a6e5c65d88",
+        "size_in_bytes": 3634
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/sysconfig.py",
+        "path_type": "hardlink",
+        "sha256": "33ff692920a02176bf7adbc8cf387600ebaf04b008581ef45a69f4113e2168a9",
+        "sha256_in_prefix": "33ff692920a02176bf7adbc8cf387600ebaf04b008581ef45a69f4113e2168a9",
+        "size_in_bytes": 19266
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "8fe2283d912d42fdc438fbaa353c1a96be862f2463cc20be38e68dbd9ce61ec2",
+        "sha256_in_prefix": "8fe2283d912d42fdc438fbaa353c1a96be862f2463cc20be38e68dbd9ce61ec2",
+        "size_in_bytes": 1485
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0b1e442eda3c484a4b98b33699749e1f1bd0537ac15f9972dde43de950b766df",
+        "sha256_in_prefix": "0b1e442eda3c484a4b98b33699749e1f1bd0537ac15f9972dde43de950b766df",
+        "size_in_bytes": 1471
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/support.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cdc2103e707441440b816c9b1cc00b42b7062831e44be1f0d66d24a7efdbe49d",
+        "sha256_in_prefix": "cdc2103e707441440b816c9b1cc00b42b7062831e44be1f0d66d24a7efdbe49d",
+        "size_in_bytes": 5050
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "01288bdf2e691432f3f19053ec204ed77d6ca7d4a3e561e737eb22063811f42e",
+        "sha256_in_prefix": "01288bdf2e691432f3f19053ec204ed77d6ca7d4a3e561e737eb22063811f42e",
+        "size_in_bytes": 10948
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1c25e80291d31104e62ec712b9783088219f9da0bb3bcd28dd267097fcd1743c",
+        "sha256_in_prefix": "1c25e80291d31104e62ec712b9783088219f9da0bb3bcd28dd267097fcd1743c",
+        "size_in_bytes": 1280
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e5d1c6b4a901242a3eefa0225f6f9ee75a11fcc4220a05787a59532e6a69c1b7",
+        "sha256_in_prefix": "e5d1c6b4a901242a3eefa0225f6f9ee75a11fcc4220a05787a59532e6a69c1b7",
+        "size_in_bytes": 2082
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "377d10980aacd7e6cb685671b6eb5958ed6dfb8835380d09cdd005132382603b",
+        "sha256_in_prefix": "377d10980aacd7e6cb685671b6eb5958ed6dfb8835380d09cdd005132382603b",
+        "size_in_bytes": 2986
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "edea0aeeff99e0556f21ab0a75634f5eb9edf0d1a2b280ca51c6088b797c9982",
+        "sha256_in_prefix": "edea0aeeff99e0556f21ab0a75634f5eb9edf0d1a2b280ca51c6088b797c9982",
+        "size_in_bytes": 1438
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fd354471458e343cb3bd1b643ee3e3be7259133cc5ec7e6213006f86e5fa891a",
+        "sha256_in_prefix": "fd354471458e343cb3bd1b643ee3e3be7259133cc5ec7e6213006f86e5fa891a",
+        "size_in_bytes": 3711
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a94e482a4fabce9e674ec0eb88c64825a52808e0ffb233093bdad44eba787f40",
+        "sha256_in_prefix": "a94e482a4fabce9e674ec0eb88c64825a52808e0ffb233093bdad44eba787f40",
+        "size_in_bytes": 13633
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build_py.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0a432603833010ab5d965a3441303be57af92547f889f64d3907f8c6ef93a2e8",
+        "sha256_in_prefix": "0a432603833010ab5d965a3441303be57af92547f889f64d3907f8c6ef93a2e8",
+        "size_in_bytes": 5547
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_build_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "97201d71aaceaecef0baa48bb9ecfb3984f610c9bbaccf0bda18a1a228ab970b",
+        "sha256_in_prefix": "97201d71aaceaecef0baa48bb9ecfb3984f610c9bbaccf0bda18a1a228ab970b",
+        "size_in_bytes": 3103
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_ccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9cb5c7094369bbe28afa337c74cacdc5adb45d77d1fca4b2b4d1f8cfb0230e2b",
+        "sha256_in_prefix": "9cb5c7094369bbe28afa337c74cacdc5adb45d77d1fca4b2b4d1f8cfb0230e2b",
+        "size_in_bytes": 2719
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_check.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d515935faf1b092bf33d95fa67697aae133f2e47962606ab2057232fd5400a3c",
+        "sha256_in_prefix": "d515935faf1b092bf33d95fa67697aae133f2e47962606ab2057232fd5400a3c",
+        "size_in_bytes": 4382
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_clean.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9785160ce5de26e9ddca2463584f82696de257333868e3846e08415990750e99",
+        "sha256_in_prefix": "9785160ce5de26e9ddca2463584f82696de257333868e3846e08415990750e99",
+        "size_in_bytes": 1289
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_cmd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "56371287b7ee0b915867cb9a4187f3866a457e4ac1d97ee7c948909fd2bf1da3",
+        "sha256_in_prefix": "56371287b7ee0b915867cb9a4187f3866a457e4ac1d97ee7c948909fd2bf1da3",
+        "size_in_bytes": 4029
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_config_cmd.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "28a2474da0208f0b77f24c65b1bb415f61d897a9d48b11f202af8d8035e5064d",
+        "sha256_in_prefix": "28a2474da0208f0b77f24c65b1bb415f61d897a9d48b11f202af8d8035e5064d",
+        "size_in_bytes": 3003
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_core.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "513006d9c0c9f4d2e3cf95a902c1ce194a5bafb0ae4a085dce7c364b100fafc1",
+        "sha256_in_prefix": "513006d9c0c9f4d2e3cf95a902c1ce194a5bafb0ae4a085dce7c364b100fafc1",
+        "size_in_bytes": 3948
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_cygwinccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c20ff0e65a14d39818113a89f5866d2975f60d5c4a3a2030d23e5c2b6c39886c",
+        "sha256_in_prefix": "c20ff0e65a14d39818113a89f5866d2975f60d5c4a3a2030d23e5c2b6c39886c",
+        "size_in_bytes": 2915
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_dir_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "855ad4ce7cecfc13539d1be4b8c252516faaaf85d7bb65e057059b5c21c678f9",
+        "sha256_in_prefix": "855ad4ce7cecfc13539d1be4b8c252516faaaf85d7bb65e057059b5c21c678f9",
+        "size_in_bytes": 4901
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_dist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8e769be2a28bdd7b344beb6938897424186716da660afe2ef3db7acaf6642da5",
+        "sha256_in_prefix": "8e769be2a28bdd7b344beb6938897424186716da660afe2ef3db7acaf6642da5",
+        "size_in_bytes": 17136
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_extension.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "675e473759c850d755e86b3c411dcd37d2a068a472e80db1dc69a509332ded00",
+        "sha256_in_prefix": "675e473759c850d755e86b3c411dcd37d2a068a472e80db1dc69a509332ded00",
+        "size_in_bytes": 2590
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_file_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "61a8be4cf2aa4bb102133603e0db09bd4b0e22f071b394c44454fb35ef2b0a1d",
+        "sha256_in_prefix": "61a8be4cf2aa4bb102133603e0db09bd4b0e22f071b394c44454fb35ef2b0a1d",
+        "size_in_bytes": 3419
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_filelist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4053f08b6194b1f4bbe889bb200a623ca01cdb8e5ff310f8a7610646db7ca726",
+        "sha256_in_prefix": "4053f08b6194b1f4bbe889bb200a623ca01cdb8e5ff310f8a7610646db7ca726",
+        "size_in_bytes": 8316
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2720312c8c49bbd60f6147b2e75870f911ddf1e01de93081b001a001d3406c7d",
+        "sha256_in_prefix": "2720312c8c49bbd60f6147b2e75870f911ddf1e01de93081b001a001d3406c7d",
+        "size_in_bytes": 7397
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install_data.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "edd885ebd7ad37d70909f988fce56b13c0cd67ddec4609e98c25b7593fa23853",
+        "sha256_in_prefix": "edd885ebd7ad37d70909f988fce56b13c0cd67ddec4609e98c25b7593fa23853",
+        "size_in_bytes": 1848
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install_headers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8b6b89a1c0f7b76fdddd978c2a82580aa37d9d5be6d068aa8107941ad8cf8aa6",
+        "sha256_in_prefix": "8b6b89a1c0f7b76fdddd978c2a82580aa37d9d5be6d068aa8107941ad8cf8aa6",
+        "size_in_bytes": 1134
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install_lib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "524f1f771d03f6dc884ff4b3d22d8f709f7c0fab058e8fe4ece273752b96a98f",
+        "sha256_in_prefix": "524f1f771d03f6dc884ff4b3d22d8f709f7c0fab058e8fe4ece273752b96a98f",
+        "size_in_bytes": 3277
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_install_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "56b85a221093a710c179ea7e2d429df8bd548d41f6714273cff2fcf31b7b1354",
+        "sha256_in_prefix": "56b85a221093a710c179ea7e2d429df8bd548d41f6714273cff2fcf31b7b1354",
+        "size_in_bytes": 1649
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_log.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4662ef54ff807d82f95d1e3fcb1f4e7fa6f417dcb1573756555d2a1254484392",
+        "sha256_in_prefix": "4662ef54ff807d82f95d1e3fcb1f4e7fa6f417dcb1573756555d2a1254484392",
+        "size_in_bytes": 685
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_mingwccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e534f2ddff348f9b8738d040a73c1e4360f0741e0a170ef6864efebc8aedc7bd",
+        "sha256_in_prefix": "e534f2ddff348f9b8738d040a73c1e4360f0741e0a170ef6864efebc8aedc7bd",
+        "size_in_bytes": 2537
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_modified.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bb5341062900b5b73f9c98429de2eb106a4e5839199b787bc987ed727ad1f999",
+        "sha256_in_prefix": "bb5341062900b5b73f9c98429de2eb106a4e5839199b787bc987ed727ad1f999",
+        "size_in_bytes": 4160
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_msvccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dae8c03cba51d6eeccc34a9b977d5d087c247526e3283ca1fbdc6e440116124c",
+        "sha256_in_prefix": "dae8c03cba51d6eeccc34a9b977d5d087c247526e3283ca1fbdc6e440116124c",
+        "size_in_bytes": 5140
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_sdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f169bd4fad33a7866ca3bf7587260714d08bc03bc275719b21ec5da8eea2c59d",
+        "sha256_in_prefix": "f169bd4fad33a7866ca3bf7587260714d08bc03bc275719b21ec5da8eea2c59d",
+        "size_in_bytes": 11204
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_spawn.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f3df93d507dd9be05aefb968d8afa304dcb8ba8f731879eadb9f042f91f4ab88",
+        "sha256_in_prefix": "f3df93d507dd9be05aefb968d8afa304dcb8ba8f731879eadb9f042f91f4ab88",
+        "size_in_bytes": 3528
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_sysconfig.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0be11723e8054225830eaee8e9b43e0e22833246e047e21ec49516dbcb6beed6",
+        "sha256_in_prefix": "0be11723e8054225830eaee8e9b43e0e22833246e047e21ec49516dbcb6beed6",
+        "size_in_bytes": 10929
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_text_file.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0b797462523028ab50791fe0bc9e2b607f73db72766c94e165d877e0bd8deba6",
+        "sha256_in_prefix": "0b797462523028ab50791fe0bc9e2b607f73db72766c94e165d877e0bd8deba6",
+        "size_in_bytes": 2143
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_unixccompiler.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1014995995a5d1815a4a77085eb3a2cb4091bb529f65ba3294d8a417b0b5275d",
+        "sha256_in_prefix": "1014995995a5d1815a4a77085eb3a2cb4091bb529f65ba3294d8a417b0b5275d",
+        "size_in_bytes": 9586
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "62734e698c2c23a69be8295cf10b5271012bb5dd681895919861c792020a1e91",
+        "sha256_in_prefix": "62734e698c2c23a69be8295cf10b5271012bb5dd681895919861c792020a1e91",
+        "size_in_bytes": 7817
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "93f03b10b29a0d0aa4d9c927bc03f7c84d0d104ecdb53a4158c0a10f7c3ed907",
+        "sha256_in_prefix": "93f03b10b29a0d0aa4d9c927bc03f7c84d0d104ecdb53a4158c0a10f7c3ed907",
+        "size_in_bytes": 2436
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "67c081957bd1a7ae2965c6c938f38a8bc32304d47cc974990ba58711beba980e",
+        "sha256_in_prefix": "67c081957bd1a7ae2965c6c938f38a8bc32304d47cc974990ba58711beba980e",
+        "size_in_bytes": 161
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/__pycache__/unix_compat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "09570fb42ac4d15903229b344b6a7e48a8dd518e32238d811957d3613a341700",
+        "sha256_in_prefix": "09570fb42ac4d15903229b344b6a7e48a8dd518e32238d811957d3613a341700",
+        "size_in_bytes": 495
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/compat/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/compat/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4e39b3c35b1f67f0fd136f96bf74eeaaa7952e52e69b4f11093c33a040d23ac4",
+        "sha256_in_prefix": "4e39b3c35b1f67f0fd136f96bf74eeaaa7952e52e69b4f11093c33a040d23ac4",
+        "size_in_bytes": 155
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/compat/__pycache__/py39.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d514793d9dd293938fd0f439515c5cb5abf456ad6159c7870359633c0713f0d0",
+        "sha256_in_prefix": "d514793d9dd293938fd0f439515c5cb5abf456ad6159c7870359633c0713f0d0",
+        "size_in_bytes": 568
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/compat/py39.py",
+        "path_type": "hardlink",
+        "sha256": "b741814ccfb7d235fef7309f93094d045b73cda6de9b1eb4eb9989d1df7f551c",
+        "sha256_in_prefix": "b741814ccfb7d235fef7309f93094d045b73cda6de9b1eb4eb9989d1df7f551c",
+        "size_in_bytes": 1026
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/support.py",
+        "path_type": "hardlink",
+        "sha256": "b63b18b32c6fa532b836b902b1e876ba3bc320657431ffdbe522397cfd93d323",
+        "sha256_in_prefix": "b63b18b32c6fa532b836b902b1e876ba3bc320657431ffdbe522397cfd93d323",
+        "size_in_bytes": 4099
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_archive_util.py",
+        "path_type": "hardlink",
+        "sha256": "8e8ce2992c0f045f89a097cdfef0da895199a7ae8135c5991a1df81655b9ec34",
+        "sha256_in_prefix": "8e8ce2992c0f045f89a097cdfef0da895199a7ae8135c5991a1df81655b9ec34",
+        "size_in_bytes": 11787
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_bdist.py",
+        "path_type": "hardlink",
+        "sha256": "c4d1f152c2e51ec6504709332dbfe2483db8b3ef4c93e357d9f7c15b03b23f27",
+        "sha256_in_prefix": "c4d1f152c2e51ec6504709332dbfe2483db8b3ef4c93e357d9f7c15b03b23f27",
+        "size_in_bytes": 1396
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_bdist_dumb.py",
+        "path_type": "hardlink",
+        "sha256": "405d393073613ce759ca1f3c5e9c3c2ac3bae2cee9445925f0a2fe4685785cad",
+        "sha256_in_prefix": "405d393073613ce759ca1f3c5e9c3c2ac3bae2cee9445925f0a2fe4685785cad",
+        "size_in_bytes": 2247
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_bdist_rpm.py",
+        "path_type": "hardlink",
+        "sha256": "1dd9bea705a0c9aa067466c470665af1c461194e39cbc8072bcba639a9d38e29",
+        "sha256_in_prefix": "1dd9bea705a0c9aa067466c470665af1c461194e39cbc8072bcba639a9d38e29",
+        "size_in_bytes": 3932
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_build.py",
+        "path_type": "hardlink",
+        "sha256": "2496395e9399728db9658d29b2dc65fa223c987b163f4ba37f9a3c68eb6e6586",
+        "sha256_in_prefix": "2496395e9399728db9658d29b2dc65fa223c987b163f4ba37f9a3c68eb6e6586",
+        "size_in_bytes": 1742
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_build_clib.py",
+        "path_type": "hardlink",
+        "sha256": "328d5915be02d555c160e1af9da965c0ded80a74edaf6e1a90b0cef198b80ac6",
+        "sha256_in_prefix": "328d5915be02d555c160e1af9da965c0ded80a74edaf6e1a90b0cef198b80ac6",
+        "size_in_bytes": 4331
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_build_ext.py",
+        "path_type": "hardlink",
+        "sha256": "23a1d4cd7e8c8035b6e6fe01dfd5c12ea3df553f12c863a5d56fb7d9e84864e3",
+        "sha256_in_prefix": "23a1d4cd7e8c8035b6e6fe01dfd5c12ea3df553f12c863a5d56fb7d9e84864e3",
+        "size_in_bytes": 19954
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_build_py.py",
+        "path_type": "hardlink",
+        "sha256": "36c7e646ba2338705734ca9647f9a9e60e0f2d3823843ee264551f7c664521dc",
+        "sha256_in_prefix": "36c7e646ba2338705734ca9647f9a9e60e0f2d3823843ee264551f7c664521dc",
+        "size_in_bytes": 6882
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_build_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "703f85472fa85f9e6c5d15f9133e7140269e1eb59a8f229ce17bb0bf67dee3cc",
+        "sha256_in_prefix": "703f85472fa85f9e6c5d15f9133e7140269e1eb59a8f229ce17bb0bf67dee3cc",
+        "size_in_bytes": 2880
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_ccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "b8bbdd69a135f052769d31fe310ebb20f927a98686d4e43ecf4d28934263c0c0",
+        "sha256_in_prefix": "b8bbdd69a135f052769d31fe310ebb20f927a98686d4e43ecf4d28934263c0c0",
+        "size_in_bytes": 3026
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_check.py",
+        "path_type": "hardlink",
+        "sha256": "847495d3ba9fed8a12c46b136dbb1443db6cb19cf945135d6eb635b364b06852",
+        "sha256_in_prefix": "847495d3ba9fed8a12c46b136dbb1443db6cb19cf945135d6eb635b364b06852",
+        "size_in_bytes": 6226
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_clean.py",
+        "path_type": "hardlink",
+        "sha256": "84f1fa8df22918552bbd66c5d6dc6488d55235a031b76c2ae578d5e3df733b81",
+        "sha256_in_prefix": "84f1fa8df22918552bbd66c5d6dc6488d55235a031b76c2ae578d5e3df733b81",
+        "size_in_bytes": 1240
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_cmd.py",
+        "path_type": "hardlink",
+        "sha256": "6e0441efd9a2b6838a4753a2c991e70a882f1b1b77a56931793a880b4e254164",
+        "sha256_in_prefix": "6e0441efd9a2b6838a4753a2c991e70a882f1b1b77a56931793a880b4e254164",
+        "size_in_bytes": 3254
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_config_cmd.py",
+        "path_type": "hardlink",
+        "sha256": "66ce965f421fc43be6b82d7d5f3b953676029d3afd63e865ef74c09834813786",
+        "sha256_in_prefix": "66ce965f421fc43be6b82d7d5f3b953676029d3afd63e865ef74c09834813786",
+        "size_in_bytes": 2664
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_core.py",
+        "path_type": "hardlink",
+        "sha256": "2fb5ca540c5af8c1a8019780368a67b8af5f44a9de621912429830f1742f705f",
+        "sha256_in_prefix": "2fb5ca540c5af8c1a8019780368a67b8af5f44a9de621912429830f1742f705f",
+        "size_in_bytes": 3829
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_cygwinccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "8aac6c0f2d19e594d183133c011ccf5da922b50a1dd95f1a1b9a9eb7f279b538",
+        "sha256_in_prefix": "8aac6c0f2d19e594d183133c011ccf5da922b50a1dd95f1a1b9a9eb7f279b538",
+        "size_in_bytes": 2753
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_dir_util.py",
+        "path_type": "hardlink",
+        "sha256": "13ce250be938ae2554c1447259a43426ac76ba2dbe8a8fb446e25adcceea909b",
+        "sha256_in_prefix": "13ce250be938ae2554c1447259a43426ac76ba2dbe8a8fb446e25adcceea909b",
+        "size_in_bytes": 4500
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_dist.py",
+        "path_type": "hardlink",
+        "sha256": "6bac257397d025de6a43a1ce9ddcdcba93618d3c6f8fafbf24bb69b98bda3f53",
+        "sha256_in_prefix": "6bac257397d025de6a43a1ce9ddcdcba93618d3c6f8fafbf24bb69b98bda3f53",
+        "size_in_bytes": 18793
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_extension.py",
+        "path_type": "hardlink",
+        "sha256": "f987a32e0642bb2705ace05deb8a551f426fc0c73d3708731ef431bef8d71ea9",
+        "sha256_in_prefix": "f987a32e0642bb2705ace05deb8a551f426fc0c73d3708731ef431bef8d71ea9",
+        "size_in_bytes": 3670
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_file_util.py",
+        "path_type": "hardlink",
+        "sha256": "962be39e5dc592295096b076ac574542af67be3115647ca73726b46dfceffdbe",
+        "sha256_in_prefix": "962be39e5dc592295096b076ac574542af67be3115647ca73726b46dfceffdbe",
+        "size_in_bytes": 3522
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_filelist.py",
+        "path_type": "hardlink",
+        "sha256": "ac9c24a8251f9060e05a50f6d93a33b13f3271bba930707c0d7a93873c13d53e",
+        "sha256_in_prefix": "ac9c24a8251f9060e05a50f6d93a33b13f3271bba930707c0d7a93873c13d53e",
+        "size_in_bytes": 10766
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_install.py",
+        "path_type": "hardlink",
+        "sha256": "4df081d32921231c9d202d90e12b93019cd21efb5e30782b04bf708684a02bd4",
+        "sha256_in_prefix": "4df081d32921231c9d202d90e12b93019cd21efb5e30782b04bf708684a02bd4",
+        "size_in_bytes": 8618
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_install_data.py",
+        "path_type": "hardlink",
+        "sha256": "bcaab72bdee4d210409ce837f279b011d7fb7040d5afdad357209e2689606f80",
+        "sha256_in_prefix": "bcaab72bdee4d210409ce837f279b011d7fb7040d5afdad357209e2689606f80",
+        "size_in_bytes": 2464
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_install_headers.py",
+        "path_type": "hardlink",
+        "sha256": "3d5018a68fed625f7cd107fae033ce9a64afc9e7c81dd534e9fed5b09799ca41",
+        "sha256_in_prefix": "3d5018a68fed625f7cd107fae033ce9a64afc9e7c81dd534e9fed5b09799ca41",
+        "size_in_bytes": 936
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_install_lib.py",
+        "path_type": "hardlink",
+        "sha256": "aab8ba465fa668d4d0acd0d5f036de5cd974863b1f4482a2238adf64bae65812",
+        "sha256_in_prefix": "aab8ba465fa668d4d0acd0d5f036de5cd974863b1f4482a2238adf64bae65812",
+        "size_in_bytes": 3612
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_install_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "284defd1c0e4156fbdd083880fe3a665918cda6872f99904bae5bb5174b6487c",
+        "sha256_in_prefix": "284defd1c0e4156fbdd083880fe3a665918cda6872f99904bae5bb5174b6487c",
+        "size_in_bytes": 1600
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_log.py",
+        "path_type": "hardlink",
+        "sha256": "8ac16d3ae7e5a02c84759690395edc554af8e86c2d755323e37986041e571fb9",
+        "sha256_in_prefix": "8ac16d3ae7e5a02c84759690395edc554af8e86c2d755323e37986041e571fb9",
+        "size_in_bytes": 323
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_mingwccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "98197c5bc4083b6c72e1e3a3e9a0045689b89686f0a4733e1ef154217bbaab47",
+        "sha256_in_prefix": "98197c5bc4083b6c72e1e3a3e9a0045689b89686f0a4733e1ef154217bbaab47",
+        "size_in_bytes": 2202
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_modified.py",
+        "path_type": "hardlink",
+        "sha256": "875fbe6ce5a6b49a356e9555eae4617674bd6ebef508188d0ccd4c0f0486a6e8",
+        "sha256_in_prefix": "875fbe6ce5a6b49a356e9555eae4617674bd6ebef508188d0ccd4c0f0486a6e8",
+        "size_in_bytes": 4221
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_msvccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "c54adfc82c023b9ec312cc5ca0beacf981b760865196562c2ae6a065b04f149d",
+        "sha256_in_prefix": "c54adfc82c023b9ec312cc5ca0beacf981b760865196562c2ae6a065b04f149d",
+        "size_in_bytes": 4301
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_sdist.py",
+        "path_type": "hardlink",
+        "sha256": "227b1b534f5a795749b63f10cb04449d466e577d9bbe2e3b791987de2590c249",
+        "sha256_in_prefix": "227b1b534f5a795749b63f10cb04449d466e577d9bbe2e3b791987de2590c249",
+        "size_in_bytes": 15058
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_spawn.py",
+        "path_type": "hardlink",
+        "sha256": "792f30f43edb4f1c852d2c916a12567ae87c29cd45f11596898fdd486e41e417",
+        "sha256_in_prefix": "792f30f43edb4f1c852d2c916a12567ae87c29cd45f11596898fdd486e41e417",
+        "size_in_bytes": 4803
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_sysconfig.py",
+        "path_type": "hardlink",
+        "sha256": "97133c2ec522d53a268c35781e860af2ee6752806478d2fad14abc3d8d437305",
+        "sha256_in_prefix": "97133c2ec522d53a268c35781e860af2ee6752806478d2fad14abc3d8d437305",
+        "size_in_bytes": 11986
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_text_file.py",
+        "path_type": "hardlink",
+        "sha256": "59059207901f7410d968c03c045822a493e7b096ffd9228c7cbf747d291156dc",
+        "sha256_in_prefix": "59059207901f7410d968c03c045822a493e7b096ffd9228c7cbf747d291156dc",
+        "size_in_bytes": 3460
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_unixccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "5b0084d333d8344da75520ee4d8270b51f81a66134b6e4c99423507de57f24e2",
+        "sha256_in_prefix": "5b0084d333d8344da75520ee4d8270b51f81a66134b6e4c99423507de57f24e2",
+        "size_in_bytes": 11835
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_util.py",
+        "path_type": "hardlink",
+        "sha256": "1fdce5678cf8561e137e33580c1b313fbc20b902e9c427c963239c9b5c995377",
+        "sha256_in_prefix": "1fdce5678cf8561e137e33580c1b313fbc20b902e9c427c963239c9b5c995377",
+        "size_in_bytes": 7988
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_version.py",
+        "path_type": "hardlink",
+        "sha256": "6a17e0fe63fcc11cb5b20c18fbf3f1e61ae381febfba94c8a670a0a51e325919",
+        "sha256_in_prefix": "6a17e0fe63fcc11cb5b20c18fbf3f1e61ae381febfba94c8a670a0a51e325919",
+        "size_in_bytes": 2750
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/test_versionpredicate.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/tests/unix_compat.py",
+        "path_type": "hardlink",
+        "sha256": "cfea29e82da255d5f56aae4120147b72a3b18a3284f7b6a537026a1cd74ba682",
+        "sha256_in_prefix": "cfea29e82da255d5f56aae4120147b72a3b18a3284f7b6a537026a1cd74ba682",
+        "size_in_bytes": 386
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/text_file.py",
+        "path_type": "hardlink",
+        "sha256": "cf876438906bf41a362c6d1336a9bcb03eb72c411a29248fd09d1b581ac51b77",
+        "sha256_in_prefix": "cf876438906bf41a362c6d1336a9bcb03eb72c411a29248fd09d1b581ac51b77",
+        "size_in_bytes": 12101
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/unixccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "4091cd71088cb5670e4385b3ba9cc8bf59d0c0110da3e6cd91e542495993e099",
+        "sha256_in_prefix": "4091cd71088cb5670e4385b3ba9cc8bf59d0c0110da3e6cd91e542495993e099",
+        "size_in_bytes": 15437
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/util.py",
+        "path_type": "hardlink",
+        "sha256": "6d785fb6ecfad68b331afc335d4b6ff64b5e18d7beed89854c4bb7dc3ea94217",
+        "sha256_in_prefix": "6d785fb6ecfad68b331afc335d4b6ff64b5e18d7beed89854c4bb7dc3ea94217",
+        "size_in_bytes": 17493
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/version.py",
+        "path_type": "hardlink",
+        "sha256": "bc8993e7e1025e4436d6828bd17605893a8ae8dc8cd3d729cc136803fdf80905",
+        "sha256_in_prefix": "bc8993e7e1025e4436d6828bd17605893a8ae8dc8cd3d729cc136803fdf80905",
+        "size_in_bytes": 12619
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/versionpredicate.py",
+        "path_type": "hardlink",
+        "sha256": "a81590eb04e3d76383cada13988c9d79f218da36f8b98d6c75b81bb8b9fe2093",
+        "sha256_in_prefix": "a81590eb04e3d76383cada13988c9d79f218da36f8b98d6c75b81bb8b9fe2093",
+        "size_in_bytes": 5205
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_distutils/zosccompiler.py",
+        "path_type": "hardlink",
+        "sha256": "6dbd9d4281a7b2fe0b9a84017e3843b1a3a9b7fa7947bcbfdbc975725b661bde",
+        "sha256_in_prefix": "6dbd9d4281a7b2fe0b9a84017e3843b1a3a9b7fa7947bcbfdbc975725b661bde",
+        "size_in_bytes": 6589
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_entry_points.py",
+        "path_type": "hardlink",
+        "sha256": "63741413d24a156fd8caab839e97df3564ace9fde3284b757be767c7efbdf8ac",
+        "sha256_in_prefix": "63741413d24a156fd8caab839e97df3564ace9fde3284b757be767c7efbdf8ac",
+        "size_in_bytes": 2310
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_imp.py",
+        "path_type": "hardlink",
+        "sha256": "618d448d910dfb4cd8722d5cc4ed7407f69d0043abee2f1e2bc26809cf487ab7",
+        "sha256_in_prefix": "618d448d910dfb4cd8722d5cc4ed7407f69d0043abee2f1e2bc26809cf487ab7",
+        "size_in_bytes": 2435
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_importlib.py",
+        "path_type": "hardlink",
+        "sha256": "68a22370ad07297373d83f974ebc5a8b11a7fe3b9390e3709aeddd72178c385d",
+        "sha256_in_prefix": "68a22370ad07297373d83f974ebc5a8b11a7fe3b9390e3709aeddd72178c385d",
+        "size_in_bytes": 223
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_itertools.py",
+        "path_type": "hardlink",
+        "sha256": "8d645fb08ae90bb9b2a28cf78435118fd1adbe9b3065e2978361da926121363a",
+        "sha256_in_prefix": "8d645fb08ae90bb9b2a28cf78435118fd1adbe9b3065e2978361da926121363a",
+        "size_in_bytes": 657
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_normalization.py",
+        "path_type": "hardlink",
+        "sha256": "b7e49e5dcd23536c1e418f41037a869514e1cc1343d6860ae47a73835ff9df78",
+        "sha256_in_prefix": "b7e49e5dcd23536c1e418f41037a869514e1cc1343d6860ae47a73835ff9df78",
+        "size_in_bytes": 4536
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_path.py",
+        "path_type": "hardlink",
+        "sha256": "70fbf8d6fd371c3eee118a82228f84fdc1917e93d5af8972c010a22be1d2ac28",
+        "sha256_in_prefix": "70fbf8d6fd371c3eee118a82228f84fdc1917e93d5af8972c010a22be1d2ac28",
+        "size_in_bytes": 2685
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_reqs.py",
+        "path_type": "hardlink",
+        "sha256": "408dc2f6e38148d45c72edb4f2a3e78b11f1e759f10abcbbfe73d32096926313",
+        "sha256_in_prefix": "408dc2f6e38148d45c72edb4f2a3e78b11f1e759f10abcbbfe73d32096926313",
+        "size_in_bytes": 1438
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_shutil.py",
+        "path_type": "hardlink",
+        "sha256": "7003a595ca323135ece492e8c9b422dbdc88e6000193cda17a9272381bf66ccc",
+        "sha256_in_prefix": "7003a595ca323135ece492e8c9b422dbdc88e6000193cda17a9272381bf66ccc",
+        "size_in_bytes": 1496
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_static.py",
+        "path_type": "hardlink",
+        "sha256": "c35d1bbf4e8d4a938587008d0b715091e54dcdc899bc8ccd669f0d5f7d356e1b",
+        "sha256_in_prefix": "c35d1bbf4e8d4a938587008d0b715091e54dcdc899bc8ccd669f0d5f7d356e1b",
+        "size_in_bytes": 4855
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/__pycache__/typing_extensions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4a919f7f9be2373ba15633b70da00a27567f8ef132a9135454851348f08a2544",
+        "sha256_in_prefix": "4a919f7f9be2373ba15633b70da00a27567f8ef132a9135454851348f08a2544",
+        "size_in_bytes": 101700
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "ade78d04982d69972d444a8e14a94f87a2334dd3855cc80348ea8e240aa0df2d",
+        "sha256_in_prefix": "ade78d04982d69972d444a8e14a94f87a2334dd3855cc80348ea8e240aa0df2d",
+        "size_in_bytes": 7634
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "3800d9b91dceea2065a6ed6279383362e97ac38b8e56b9343f404ee531860099",
+        "sha256_in_prefix": "3800d9b91dceea2065a6ed6279383362e97ac38b8e56b9343f404ee531860099",
+        "size_in_bytes": 15006
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "822bba66b41526fa547186b80221f85da50d652bee5493dbfe5d14085112f0c3",
+        "sha256_in_prefix": "822bba66b41526fa547186b80221f85da50d652bee5493dbfe5d14085112f0c3",
+        "size_in_bytes": 1308
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "db07a93359e4e034b8785a58ad6d534ea3dca0635f1e184efe2e66e1c3a299ba",
+        "sha256_in_prefix": "db07a93359e4e034b8785a58ad6d534ea3dca0635f1e184efe2e66e1c3a299ba",
+        "size_in_bytes": 92
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand-2.2.2.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "0337e180a292f04740c16513485f2681e5506d7398f64a241c1ea44aac30aaed",
+        "sha256_in_prefix": "0337e180a292f04740c16513485f2681e5506d7398f64a241c1ea44aac30aaed",
+        "size_in_bytes": 12
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "ce4a39467be896f6fe5178c2c7fd80acf4c6056c142b9418e0b21020a611ec0b",
+        "sha256_in_prefix": "ce4a39467be896f6fe5178c2c7fd80acf4c6056c142b9418e0b21020a611ec0b",
+        "size_in_bytes": 1037
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ee1cd35b0dd22814a83d9fd2276e4693717b097ff313537106c940e01416f8dd",
+        "sha256_in_prefix": "ee1cd35b0dd22814a83d9fd2276e4693717b097ff313537106c940e01416f8dd",
+        "size_in_bytes": 344
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/autoasync.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ec9d7120e073cb1918f88245f241a8ffb4188974aa49390248f999e940f8e649",
+        "sha256_in_prefix": "ec9d7120e073cb1918f88245f241a8ffb4188974aa49390248f999e940f8e649",
+        "size_in_bytes": 4114
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/autocommand.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "492717806c121e1fe9056dd216b08b68976bfb5c662d51755a635c53afd40f1a",
+        "sha256_in_prefix": "492717806c121e1fe9056dd216b08b68976bfb5c662d51755a635c53afd40f1a",
+        "size_in_bytes": 989
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/automain.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "59352fc0fd2100dd7a16b9d79febadc549f5976ac2c1d9f7bfa77fcd3e71f76c",
+        "sha256_in_prefix": "59352fc0fd2100dd7a16b9d79febadc549f5976ac2c1d9f7bfa77fcd3e71f76c",
+        "size_in_bytes": 1629
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/autoparse.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eb6776dfd58c52a1d82179672990a53531b5a1ad9178b7ad02e5f9887eb4b982",
+        "sha256_in_prefix": "eb6776dfd58c52a1d82179672990a53531b5a1ad9178b7ad02e5f9887eb4b982",
+        "size_in_bytes": 8422
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/__pycache__/errors.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2925d918aa7957baff3ecf172bf509075a03fcff7e66faf0c4b48ce4e94c5f4b",
+        "sha256_in_prefix": "2925d918aa7957baff3ecf172bf509075a03fcff7e66faf0c4b48ce4e94c5f4b",
+        "size_in_bytes": 374
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/autoasync.py",
+        "path_type": "hardlink",
+        "sha256": "00c772af1352e29a9625f3ffc6ea0e70898e1d60fea93ef1d3ac2628dd55a7e5",
+        "sha256_in_prefix": "00c772af1352e29a9625f3ffc6ea0e70898e1d60fea93ef1d3ac2628dd55a7e5",
+        "size_in_bytes": 5680
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/autocommand.py",
+        "path_type": "hardlink",
+        "sha256": "866904990ef61ed2f9e609d44558c33a7b1f62519de652d76ef4f8286e3de90c",
+        "sha256_in_prefix": "866904990ef61ed2f9e609d44558c33a7b1f62519de652d76ef4f8286e3de90c",
+        "size_in_bytes": 2505
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/automain.py",
+        "path_type": "hardlink",
+        "sha256": "0366fc8bbe7833173f0e353d585afabea6035a5873d1c9fc9a2bbc77c12cc55f",
+        "sha256_in_prefix": "0366fc8bbe7833173f0e353d585afabea6035a5873d1c9fc9a2bbc77c12cc55f",
+        "size_in_bytes": 2076
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/autoparse.py",
+        "path_type": "hardlink",
+        "sha256": "5955a66493dc6f350a5cfe34ada430ff41c3f2a3c9d95f551b57851669a7171c",
+        "sha256_in_prefix": "5955a66493dc6f350a5cfe34ada430ff41c3f2a3c9d95f551b57851669a7171c",
+        "size_in_bytes": 11642
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/autocommand/errors.py",
+        "path_type": "hardlink",
+        "sha256": "eda6b7ae887d1deaddea720aa501cd584b25584f28abb1a21d8554b91a8e4670",
+        "sha256_in_prefix": "eda6b7ae887d1deaddea720aa501cd584b25584f28abb1a21d8554b91a8e4670",
+        "size_in_bytes": 886
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "sha256_in_prefix": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "8215c54ead77d9dc5a108a25c6bdc72b5999aa6f62c9499a440359412afa5a51",
+        "sha256_in_prefix": "8215c54ead77d9dc5a108a25c6bdc72b5999aa6f62c9499a440359412afa5a51",
+        "size_in_bytes": 2020
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "258a1f1c849e1175069a55a5d6ce357afdd04e34cd5de27093e4acec7a9d2ce1",
+        "sha256_in_prefix": "258a1f1c849e1175069a55a5d6ce357afdd04e34cd5de27093e4acec7a9d2ce1",
+        "size_in_bytes": 1360
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "sha256_in_prefix": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "size_in_bytes": 92
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports.tarfile-1.2.0.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "7068da2cc3a8051d452b4029a23b73595995893b49ec91882bf1f05e212cbed5",
+        "sha256_in_prefix": "7068da2cc3a8051d452b4029a23b73595995893b49ec91882bf1f05e212cbed5",
+        "size_in_bytes": 10
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "88e10cc2794e4567b374ef3edafc4120f491dfb0fb2468e5b99f1fe79bf3c65b",
+        "sha256_in_prefix": "88e10cc2794e4567b374ef3edafc4120f491dfb0fb2468e5b99f1fe79bf3c65b",
+        "size_in_bytes": 81
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ad149bf490e7201ba3b4f49bfd85a7306c7ce74834eca28ce239dd381c68f530",
+        "sha256_in_prefix": "ad149bf490e7201ba3b4f49bfd85a7306c7ce74834eca28ce239dd381c68f530",
+        "size_in_bytes": 216
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/tarfile/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "3f07f6a9421f0744a89493c229cc77bf3dd412efda89db38838b007f1cbde2a8",
+        "sha256_in_prefix": "3f07f6a9421f0744a89493c229cc77bf3dd412efda89db38838b007f1cbde2a8",
+        "size_in_bytes": 108491
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/tarfile/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "630da8193d5a7ebcf6781b24cdd3d82fc45e07fde5880a6684590dd846c399ce",
+        "sha256_in_prefix": "630da8193d5a7ebcf6781b24cdd3d82fc45e07fde5880a6684590dd846c399ce",
+        "size_in_bytes": 59
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/tarfile/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "de12fe946320abb42cd0d4fda3163a1b360e5b545d818636a540618ed1670e16",
+        "sha256_in_prefix": "de12fe946320abb42cd0d4fda3163a1b360e5b545d818636a540618ed1670e16",
+        "size_in_bytes": 72337
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/tarfile/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a5798a61bd2615656d4ea8e3155ff3f86e918950bcc9ef17e862b1ea03afab4d",
+        "sha256_in_prefix": "a5798a61bd2615656d4ea8e3155ff3f86e918950bcc9ef17e862b1ea03afab4d",
+        "size_in_bytes": 224
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/tarfile/compat/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3b4e571f739da01e1c96759ad1090cd1a065a12be2b533d2ecf13b3ef6afec94",
+        "sha256_in_prefix": "3b4e571f739da01e1c96759ad1090cd1a065a12be2b533d2ecf13b3ef6afec94",
+        "size_in_bytes": 164
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/tarfile/compat/__pycache__/py38.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "883542fa9ee91fbd3ee024a6caf02a4cd0bd70389304d98084eb827d106d0456",
+        "sha256_in_prefix": "883542fa9ee91fbd3ee024a6caf02a4cd0bd70389304d98084eb827d106d0456",
+        "size_in_bytes": 764
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/backports/tarfile/compat/py38.py",
+        "path_type": "hardlink",
+        "sha256": "898932b7f82f5a32f31944c90fd4ee4df30c8ce93e7abb17666465bd060ddaa1",
+        "sha256_in_prefix": "898932b7f82f5a32f31944c90fd4ee4df30c8ce93e7abb17666465bd060ddaa1",
+        "size_in_bytes": 568
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+        "sha256_in_prefix": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30",
+        "size_in_bytes": 11358
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "6a7b90effee1e09d5b484cdf7232016a43e2d9cc9543bcbb8e494b1ec05e1f59",
+        "sha256_in_prefix": "6a7b90effee1e09d5b484cdf7232016a43e2d9cc9543bcbb8e494b1ec05e1f59",
+        "size_in_bytes": 4648
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "0d8d3c6eeb9ebbe86cac7d60861552433c329da9ea51248b61d02be2e5e64030",
+        "sha256_in_prefix": "0d8d3c6eeb9ebbe86cac7d60861552433c329da9ea51248b61d02be2e5e64030",
+        "size_in_bytes": 2518
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "9a0b8c95618c5fe5479cca4a3a38d089d228d6cb1194216ee1ae26069cf5b363",
+        "sha256_in_prefix": "9a0b8c95618c5fe5479cca4a3a38d089d228d6cb1194216ee1ae26069cf5b363",
+        "size_in_bytes": 91
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata-8.0.0.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "08eddf0fdcb29403625e4acca38a872d5fe6a972f6b02e4914a82dd725804fe0",
+        "sha256_in_prefix": "08eddf0fdcb29403625e4acca38a872d5fe6a972f6b02e4914a82dd725804fe0",
+        "size_in_bytes": 19
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "b59341fb6de1f018b18bdb82ad0aa3f587f469e0bef89a2c772dc8651210781d",
+        "sha256_in_prefix": "b59341fb6de1f018b18bdb82ad0aa3f587f469e0bef89a2c772dc8651210781d",
+        "size_in_bytes": 33798
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0bfef6a992fa4757ec408293dfeed1aa7e7bcf38ba29c328f1a06c1eef5c3949",
+        "sha256_in_prefix": "0bfef6a992fa4757ec408293dfeed1aa7e7bcf38ba29c328f1a06c1eef5c3949",
+        "size_in_bytes": 39895
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_adapters.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0712f31316293c2bf99e2bcd5210da22eaf5de77c1ef87a4943416ed3ac0d34c",
+        "sha256_in_prefix": "0712f31316293c2bf99e2bcd5210da22eaf5de77c1ef87a4943416ed3ac0d34c",
+        "size_in_bytes": 2838
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_collections.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ef7f8d216394b77c69225344287bd9c8b003af3af1f4f2e59178c770196c88f3",
+        "sha256_in_prefix": "ef7f8d216394b77c69225344287bd9c8b003af3af1f4f2e59178c770196c88f3",
+        "size_in_bytes": 1528
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_compat.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1786744e0a406a4603b45a4813cd22ade2a06be0f1b8b44eed70f664c13a6196",
+        "sha256_in_prefix": "1786744e0a406a4603b45a4813cd22ade2a06be0f1b8b44eed70f664c13a6196",
+        "size_in_bytes": 1862
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_functools.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e20754df20a5b099acf19acd9a15c139846bf182f7c4f60d21631f2e5c735166",
+        "sha256_in_prefix": "e20754df20a5b099acf19acd9a15c139846bf182f7c4f60d21631f2e5c735166",
+        "size_in_bytes": 3118
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_itertools.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "56e936d219048ea1288d743dd78dd360b093218dfcc766defc9bc5fcfc515e2f",
+        "sha256_in_prefix": "56e936d219048ea1288d743dd78dd360b093218dfcc766defc9bc5fcfc515e2f",
+        "size_in_bytes": 1995
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_meta.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "23d942d42836e641c03d39b3b42994442c44f365f74ad13d066f9f1da408c6d7",
+        "sha256_in_prefix": "23d942d42836e641c03d39b3b42994442c44f365f74ad13d066f9f1da408c6d7",
+        "size_in_bytes": 3218
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/_text.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aef1a5c92d6e9b647c9129d54883156f1366d1520975d837918e3f2ed110ee33",
+        "sha256_in_prefix": "aef1a5c92d6e9b647c9129d54883156f1366d1520975d837918e3f2ed110ee33",
+        "size_in_bytes": 3061
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/__pycache__/diagnose.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c8610a7903a264b62a63ecbd8bb95f230a6d71eb27726a9d7489d7b177b8bf37",
+        "sha256_in_prefix": "c8610a7903a264b62a63ecbd8bb95f230a6d71eb27726a9d7489d7b177b8bf37",
+        "size_in_bytes": 812
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/_adapters.py",
+        "path_type": "hardlink",
+        "sha256": "ac88564f006f600d5b57b8bee457d55f7f2a1170d35c5792e5c6f9c49b4fde4b",
+        "sha256_in_prefix": "ac88564f006f600d5b57b8bee457d55f7f2a1170d35c5792e5c6f9c49b4fde4b",
+        "size_in_bytes": 2317
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/_collections.py",
+        "path_type": "hardlink",
+        "sha256": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126",
+        "sha256_in_prefix": "089d0e4c21c88d6034648552e2fa0e440b27d91e11d9c40112d3ec6442690126",
+        "size_in_bytes": 743
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/_compat.py",
+        "path_type": "hardlink",
+        "sha256": "ef740aacdf4a368699ce16d7e723c20996be15a00bc177bc4cf94347bd898015",
+        "sha256_in_prefix": "ef740aacdf4a368699ce16d7e723c20996be15a00bc177bc4cf94347bd898015",
+        "size_in_bytes": 1314
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/_functools.py",
+        "path_type": "hardlink",
+        "sha256": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80",
+        "sha256_in_prefix": "3ec636fb8aeb297e1155e442d681a9d65075a660bd78a37cf3f7fe6c3f6e3a80",
+        "size_in_bytes": 2895
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/_itertools.py",
+        "path_type": "hardlink",
+        "sha256": "72faffdaff0145bc5c225e71e6575fa9d1e3848f188bcb3cca4e741bf9e6ea34",
+        "sha256_in_prefix": "72faffdaff0145bc5c225e71e6575fa9d1e3848f188bcb3cca4e741bf9e6ea34",
+        "size_in_bytes": 2068
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/_meta.py",
+        "path_type": "hardlink",
+        "sha256": "9f167b0bc19595c04500a5b254e9ff767ee8b7fb7005c6e6d4d9af8c87ad0472",
+        "sha256_in_prefix": "9f167b0bc19595c04500a5b254e9ff767ee8b7fb7005c6e6d4d9af8c87ad0472",
+        "size_in_bytes": 1801
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/_text.py",
+        "path_type": "hardlink",
+        "sha256": "1c2b0592c66924b7933f734493f9e0ac079755146d4ebb7287d78e001a113f80",
+        "sha256_in_prefix": "1c2b0592c66924b7933f734493f9e0ac079755146d4ebb7287d78e001a113f80",
+        "size_in_bytes": 2166
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "40e67593e7ca513e716687d18b620d556c4a794335fa8dc4444b08ca724ff4e2",
+        "sha256_in_prefix": "40e67593e7ca513e716687d18b620d556c4a794335fa8dc4444b08ca724ff4e2",
+        "size_in_bytes": 165
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/__pycache__/py311.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "23d86e79f59dc814d6a172488880e89d2fa43d679677cea5d81f1c97bab49ec4",
+        "sha256_in_prefix": "23d86e79f59dc814d6a172488880e89d2fa43d679677cea5d81f1c97bab49ec4",
+        "size_in_bytes": 1001
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/__pycache__/py39.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "971f96445c0db5032951c695e719275e8012451436cc4c0028e0f3e6382d6085",
+        "sha256_in_prefix": "971f96445c0db5032951c695e719275e8012451436cc4c0028e0f3e6382d6085",
+        "size_in_bytes": 1164
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/py311.py",
+        "path_type": "hardlink",
+        "sha256": "baa9be2beba88728f5d38d931f86bd12bfc8e68efaebb0efba5703fa00bf7d20",
+        "sha256_in_prefix": "baa9be2beba88728f5d38d931f86bd12bfc8e68efaebb0efba5703fa00bf7d20",
+        "size_in_bytes": 608
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/compat/py39.py",
+        "path_type": "hardlink",
+        "sha256": "70f90cbfafb48a52bed09c3f4e49f4c586ce28965ce1624a407a30d1cd93e38c",
+        "sha256_in_prefix": "70f90cbfafb48a52bed09c3f4e49f4c586ce28965ce1624a407a30d1cd93e38c",
+        "size_in_bytes": 1102
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/diagnose.py",
+        "path_type": "hardlink",
+        "sha256": "9e4491322a309669212d884a86f0a0f60966b7fd750a8c7e1262f311ba984daf",
+        "sha256_in_prefix": "9e4491322a309669212d884a86f0a0f60966b7fd750a8c7e1262f311ba984daf",
+        "size_in_bytes": 379
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/importlib_metadata/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "sha256_in_prefix": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "66030d634580651b3e53cc19895d9231f8d22aa06b327817c8332cfc20303308",
+        "sha256_in_prefix": "66030d634580651b3e53cc19895d9231f8d22aa06b327817c8332cfc20303308",
+        "size_in_bytes": 21079
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "5d7834ac1ba2612c6801050fde57a7b98b0f36acf88c3c2d4f376fd8911b3091",
+        "sha256_in_prefix": "5d7834ac1ba2612c6801050fde57a7b98b0f36acf88c3c2d4f376fd8911b3091",
+        "size_in_bytes": 943
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "cb8997f92397e1f6089289ec0060393743b2fbcfe0238157c391cd235c6abd68",
+        "sha256_in_prefix": "cb8997f92397e1f6089289ec0060393743b2fbcfe0238157c391cd235c6abd68",
+        "size_in_bytes": 91
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect-7.3.1.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "9b9dae8dda75d02a93ea38755d0c594fa9049ed727bfeed397b52218d4f35990",
+        "sha256_in_prefix": "9b9dae8dda75d02a93ea38755d0c594fa9049ed727bfeed397b52218d4f35990",
+        "size_in_bytes": 8
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "271cb51c95d9899f3990778b021926bf3e84313745a817be76ebeddf847a20e7",
+        "sha256_in_prefix": "271cb51c95d9899f3990778b021926bf3e84313745a817be76ebeddf847a20e7",
+        "size_in_bytes": 103796
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "004cd885c95635e7f2dc65d7a8321b69ca6dd6b5d20c1a507bcc74c76dc0685f",
+        "sha256_in_prefix": "004cd885c95635e7f2dc65d7a8321b69ca6dd6b5d20c1a507bcc74c76dc0685f",
+        "size_in_bytes": 73239
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect/compat/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect/compat/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "83f04a35c40df4b1b4f3abf54e38fd3304494db6294ea075ded8b7bc56a15d4f",
+        "sha256_in_prefix": "83f04a35c40df4b1b4f3abf54e38fd3304494db6294ea075ded8b7bc56a15d4f",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect/compat/__pycache__/py38.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bcaed994ff1723756936170cc16c17c4b4cb04e17f2bdff3c248887fee37c1a6",
+        "sha256_in_prefix": "bcaed994ff1723756936170cc16c17c4b4cb04e17f2bdff3c248887fee37c1a6",
+        "size_in_bytes": 278
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect/compat/py38.py",
+        "path_type": "hardlink",
+        "sha256": "a0e6d57d59d65fdfcea673ae1099f59856c9c55870c91e5ea5b8933570c36aca",
+        "sha256_in_prefix": "a0e6d57d59d65fdfcea673ae1099f59856c9c55870c91e5ea5b8933570c36aca",
+        "size_in_bytes": 160
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/inflect/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "sha256_in_prefix": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "20c51a96236c0395f53b1f4c5d458e6a0721e51e16c1bff733b7aba76f5d06d8",
+        "sha256_in_prefix": "20c51a96236c0395f53b1f4c5d458e6a0721e51e16c1bff733b7aba76f5d06d8",
+        "size_in_bytes": 3933
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "1e9b62bd70e4a5fa26e9594cbb80860ffeca3debfee8773daefa774cd259ca06",
+        "sha256_in_prefix": "1e9b62bd70e4a5fa26e9594cbb80860ffeca3debfee8773daefa774cd259ca06",
+        "size_in_bytes": 873
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "31d8bd3c3370119a6d3a34e551c02d87b5c90c5b4aac761a40c3ee9597810a24",
+        "sha256_in_prefix": "31d8bd3c3370119a6d3a34e551c02d87b5c90c5b4aac761a40c3ee9597810a24",
+        "size_in_bytes": 91
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.collections-5.1.0.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "d099cddcb7d71f82c845f5cbf9014e18227341664edc42f1e11d5dfe5a2ea103",
+        "sha256_in_prefix": "d099cddcb7d71f82c845f5cbf9014e18227341664edc42f1e11d5dfe5a2ea103",
+        "size_in_bytes": 7
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "sha256_in_prefix": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "c43b60b897a3d2d37d8845c252fc44261d9aef171e21154111a9012d2afffed6",
+        "sha256_in_prefix": "c43b60b897a3d2d37d8845c252fc44261d9aef171e21154111a9012d2afffed6",
+        "size_in_bytes": 4020
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "55197b88a78443297bb2d827a75baae740b33896251d872835d4b4c75ec2f57e",
+        "sha256_in_prefix": "55197b88a78443297bb2d827a75baae740b33896251d872835d4b4c75ec2f57e",
+        "size_in_bytes": 641
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "sha256_in_prefix": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "size_in_bytes": 92
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.context-5.3.0.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "d099cddcb7d71f82c845f5cbf9014e18227341664edc42f1e11d5dfe5a2ea103",
+        "sha256_in_prefix": "d099cddcb7d71f82c845f5cbf9014e18227341664edc42f1e11d5dfe5a2ea103",
+        "size_in_bytes": 7
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "sha256_in_prefix": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "8b86946900d7fa38dd1102b9c1ebe17a0cb1f09c8b7e29f61f2bda4a4dc51eca",
+        "sha256_in_prefix": "8b86946900d7fa38dd1102b9c1ebe17a0cb1f09c8b7e29f61f2bda4a4dc51eca",
+        "size_in_bytes": 2891
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "632aa7c04f7c4bcc01c027af5b9bc76fe8958f4a181035b957a3bd3014ba248b",
+        "sha256_in_prefix": "632aa7c04f7c4bcc01c027af5b9bc76fe8958f4a181035b957a3bd3014ba248b",
+        "size_in_bytes": 843
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "sha256_in_prefix": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "size_in_bytes": 92
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.functools-4.0.1.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "d099cddcb7d71f82c845f5cbf9014e18227341664edc42f1e11d5dfe5a2ea103",
+        "sha256_in_prefix": "d099cddcb7d71f82c845f5cbf9014e18227341664edc42f1e11d5dfe5a2ea103",
+        "size_in_bytes": 7
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "sha256_in_prefix": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "03359d9ba56231f0ce3e840c7cb5a7db380141218949ccaa78ddbd4dcb965d52",
+        "sha256_in_prefix": "03359d9ba56231f0ce3e840c7cb5a7db380141218949ccaa78ddbd4dcb965d52",
+        "size_in_bytes": 3658
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "816d945741dca246099388ca3eed74fc0667acbaa36f70b559b2494c3979b1f6",
+        "sha256_in_prefix": "816d945741dca246099388ca3eed74fc0667acbaa36f70b559b2494c3979b1f6",
+        "size_in_bytes": 1500
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "sha256_in_prefix": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "size_in_bytes": 92
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco.text-3.12.1.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "d099cddcb7d71f82c845f5cbf9014e18227341664edc42f1e11d5dfe5a2ea103",
+        "sha256_in_prefix": "d099cddcb7d71f82c845f5cbf9014e18227341664edc42f1e11d5dfe5a2ea103",
+        "size_in_bytes": 7
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/__pycache__/context.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d50acefb4810505a585d6de19a0310014dc313f930e44c4b6841864f75c12522",
+        "sha256_in_prefix": "d50acefb4810505a585d6de19a0310014dc313f930e44c4b6841864f75c12522",
+        "size_in_bytes": 10969
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/collections/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "3dcd7e4aa8d69bcd5a7753f4f86b6da64c0efcb5a59da63a814abc81c2a1dafd",
+        "sha256_in_prefix": "3dcd7e4aa8d69bcd5a7753f4f86b6da64c0efcb5a59da63a814abc81c2a1dafd",
+        "size_in_bytes": 26640
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/collections/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a076ef0e408e293fb0a1bc25cf864bfeec91191f83e68c516a2a8f6b56724ccc",
+        "sha256_in_prefix": "a076ef0e408e293fb0a1bc25cf864bfeec91191f83e68c516a2a8f6b56724ccc",
+        "size_in_bytes": 32438
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/collections/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/context.py",
+        "path_type": "hardlink",
+        "sha256": "444a0b2310e43b931f118a30b7f5a8ba9342468c414b9bfb617d8f6d6f2521cb",
+        "sha256_in_prefix": "444a0b2310e43b931f118a30b7f5a8ba9342468c414b9bfb617d8f6d6f2521cb",
+        "size_in_bytes": 9552
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/functools/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "844009692dae49946e17f258e02c421c8621efd669c5a3e9f4e887cabf44275c",
+        "sha256_in_prefix": "844009692dae49946e17f258e02c421c8621efd669c5a3e9f4e887cabf44275c",
+        "size_in_bytes": 16642
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/functools/__init__.pyi",
+        "path_type": "hardlink",
+        "sha256": "824dddb201f3a3917f53be07cc0be9362bc500f0a43c9d5bdbec8277ad9d7e7c",
+        "sha256_in_prefix": "824dddb201f3a3917f53be07cc0be9362bc500f0a43c9d5bdbec8277ad9d7e7c",
+        "size_in_bytes": 3878
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/functools/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "96b438493355f33a36fcabbd5184b812bf40564fe17bc3497393b6df848af769",
+        "sha256_in_prefix": "96b438493355f33a36fcabbd5184b812bf40564fe17bc3497393b6df848af769",
+        "size_in_bytes": 19254
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/functools/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/Lorem ipsum.txt",
+        "path_type": "hardlink",
+        "sha256": "37fedcffbf73c4eb9f058f47677cb33203a436ff9390e4d38a8e01c9dad28e0b",
+        "sha256_in_prefix": "37fedcffbf73c4eb9f058f47677cb33203a436ff9390e4d38a8e01c9dad28e0b",
+        "size_in_bytes": 1335
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "636614a9747fa2b5280da6384a43d17ba65985be4750707f021f5108db15ca1a",
+        "sha256_in_prefix": "636614a9747fa2b5280da6384a43d17ba65985be4750707f021f5108db15ca1a",
+        "size_in_bytes": 16250
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c8f174c7d11b74934489ca9482050eb0f4b4ae40fad4b7db935a9937d8da1a9c",
+        "sha256_in_prefix": "c8f174c7d11b74934489ca9482050eb0f4b4ae40fad4b7db935a9937d8da1a9c",
+        "size_in_bytes": 20443
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/layouts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd26119984d03d3e3f087456df1941b925c50fed7099feb310ab119ef8d02507",
+        "sha256_in_prefix": "dd26119984d03d3e3f087456df1941b925c50fed7099feb310ab119ef8d02507",
+        "size_in_bytes": 867
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/show-newlines.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e81bf1ec7c391a77e39309c0813c7fafcab32628d21e4bf7ffd6262a84c67154",
+        "sha256_in_prefix": "e81bf1ec7c391a77e39309c0813c7fafcab32628d21e4bf7ffd6262a84c67154",
+        "size_in_bytes": 1089
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/strip-prefix.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "27ec99edd8d10e6e49374577736b232ebb8a7463ef8d11bfbb32f4eb93b64c49",
+        "sha256_in_prefix": "27ec99edd8d10e6e49374577736b232ebb8a7463ef8d11bfbb32f4eb93b64c49",
+        "size_in_bytes": 637
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/to-dvorak.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d9a466ab68b0c7d3df500643cb0a1206dc2222f38dde80e1e9d8d4b4dca03a1",
+        "sha256_in_prefix": "2d9a466ab68b0c7d3df500643cb0a1206dc2222f38dde80e1e9d8d4b4dca03a1",
+        "size_in_bytes": 287
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/__pycache__/to-qwerty.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bc9684092340c859b3cd89db4fb5941f63e5d082733f5b216ddd668730313865",
+        "sha256_in_prefix": "bc9684092340c859b3cd89db4fb5941f63e5d082733f5b216ddd668730313865",
+        "size_in_bytes": 287
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/layouts.py",
+        "path_type": "hardlink",
+        "sha256": "1d30bc6924cb67bb978a9c8e5daa51302d79f23b9e7232ba455c22b5f999f7fc",
+        "sha256_in_prefix": "1d30bc6924cb67bb978a9c8e5daa51302d79f23b9e7232ba455c22b5f999f7fc",
+        "size_in_bytes": 643
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/show-newlines.py",
+        "path_type": "hardlink",
+        "sha256": "58641aeb97bc97285bf762d438ba959fa29a0ada1e560570b3a5ad49198b93ac",
+        "sha256_in_prefix": "58641aeb97bc97285bf762d438ba959fa29a0ada1e560570b3a5ad49198b93ac",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/strip-prefix.py",
+        "path_type": "hardlink",
+        "sha256": "35f55757c255368ea7a9cb980127cc57bff2e04a3cccc42a942386bc09d1215c",
+        "sha256_in_prefix": "35f55757c255368ea7a9cb980127cc57bff2e04a3cccc42a942386bc09d1215c",
+        "size_in_bytes": 412
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/to-dvorak.py",
+        "path_type": "hardlink",
+        "sha256": "d5235c6d2b2f212a575e0f8b9f26c81c763e45414e42bdfacdc1e4635a5616ac",
+        "sha256_in_prefix": "d5235c6d2b2f212a575e0f8b9f26c81c763e45414e42bdfacdc1e4635a5616ac",
+        "size_in_bytes": 119
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/jaraco/text/to-qwerty.py",
+        "path_type": "hardlink",
+        "sha256": "b3850c4149cfc059ff741e6e642dbb06eac7390718a277417f322954be69133c",
+        "sha256_in_prefix": "b3850c4149cfc059ff741e6e642dbb06eac7390718a277417f322954be69133c",
+        "size_in_bytes": 119
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "09f1c8c9e941af3e584d59641ea9b87d83c0cb0fd007eb5ef391a7e2643c1a46",
+        "sha256_in_prefix": "09f1c8c9e941af3e584d59641ea9b87d83c0cb0fd007eb5ef391a7e2643c1a46",
+        "size_in_bytes": 1053
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "0453bdd0ef9f2cd89540ca63ee8212e73b73809514419dd3037d8fe471f737e0",
+        "sha256_in_prefix": "0453bdd0ef9f2cd89540ca63ee8212e73b73809514419dd3037d8fe471f737e0",
+        "size_in_bytes": 36293
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "77c8e73e018dc0fd7e9ed6c80b05a4404545f641fb085220ce42b368b59aa3d3",
+        "sha256_in_prefix": "77c8e73e018dc0fd7e9ed6c80b05a4404545f641fb085220ce42b368b59aa3d3",
+        "size_in_bytes": 1259
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools-10.3.0.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "ad282afc9a4717d7c7475971e77ab083fd7ed8bca9644fea99cb976d552af78f",
+        "sha256_in_prefix": "ad282afc9a4717d7c7475971e77ab083fd7ed8bca9644fea99cb976d552af78f",
+        "size_in_bytes": 81
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "76d01b1a34c39a7fe08625396177e1c83cb4a610255d576de649590397d46be4",
+        "sha256_in_prefix": "76d01b1a34c39a7fe08625396177e1c83cb4a610255d576de649590397d46be4",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/__init__.pyi",
+        "path_type": "hardlink",
+        "sha256": "e41dde4f338dd4106e38ba1bd6f09f97211bda549deaeb17410f82bfe85791e0",
+        "sha256_in_prefix": "e41dde4f338dd4106e38ba1bd6f09f97211bda549deaeb17410f82bfe85791e0",
+        "size_in_bytes": 43
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2e6b58b0f0df45aecea2d3b59f3c95eb61b6f1fe044dffc4e48e65d5921db02e",
+        "sha256_in_prefix": "2e6b58b0f0df45aecea2d3b59f3c95eb61b6f1fe044dffc4e48e65d5921db02e",
+        "size_in_bytes": 296
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/__pycache__/more.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "346d563e43da0d82c23018597ef2576abdcba23dfe7e0e63709ac239a2f6a8ea",
+        "sha256_in_prefix": "346d563e43da0d82c23018597ef2576abdcba23dfe7e0e63709ac239a2f6a8ea",
+        "size_in_bytes": 138366
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/__pycache__/recipes.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e8344367852abc4984c3d9e57c1de4b8bcdeb537e442f6a6b289ef33323d712a",
+        "sha256_in_prefix": "e8344367852abc4984c3d9e57c1de4b8bcdeb537e442f6a6b289ef33323d712a",
+        "size_in_bytes": 29089
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/more.py",
+        "path_type": "hardlink",
+        "sha256": "d44e64cc59dc44a4c3c34718bf5c915cc80376e9ecb4b41dd504ad7272fa53dd",
+        "sha256_in_prefix": "d44e64cc59dc44a4c3c34718bf5c915cc80376e9ecb4b41dd504ad7272fa53dd",
+        "size_in_bytes": 148370
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/more.pyi",
+        "path_type": "hardlink",
+        "sha256": "8975deaade3c3717bc5469885a99155ee2a947615836ebb60d4f2740b5820aed",
+        "sha256_in_prefix": "8975deaade3c3717bc5469885a99155ee2a947615836ebb60d4f2740b5820aed",
+        "size_in_bytes": 21484
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/recipes.py",
+        "path_type": "hardlink",
+        "sha256": "59e76185f846560aface28bc7c86c62559914f0d1929188b2a76010c626fe276",
+        "sha256_in_prefix": "59e76185f846560aface28bc7c86c62559914f0d1929188b2a76010c626fe276",
+        "size_in_bytes": 28591
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/more_itertools/recipes.pyi",
+        "path_type": "hardlink",
+        "sha256": "4ff99d1a970575facfdc94966f0cd83fd272355f86a3eed13dfa717dfb405a50",
+        "sha256_in_prefix": "4ff99d1a970575facfdc94966f0cd83fd272355f86a3eed13dfa717dfb405a50",
+        "size_in_bytes": 4617
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "cad1ef5bd340d73e074ba614d26f7deaca5c7940c3d8c34852e65c4909686c48",
+        "sha256_in_prefix": "cad1ef5bd340d73e074ba614d26f7deaca5c7940c3d8c34852e65c4909686c48",
+        "size_in_bytes": 197
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/LICENSE.APACHE",
+        "path_type": "hardlink",
+        "sha256": "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594",
+        "sha256_in_prefix": "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594",
+        "size_in_bytes": 10174
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/LICENSE.BSD",
+        "path_type": "hardlink",
+        "sha256": "b70e7e9b742f1cc6f948b34c16aa39ffece94196364bc88ff0d2180f0028fac5",
+        "sha256_in_prefix": "b70e7e9b742f1cc6f948b34c16aa39ffece94196364bc88ff0d2180f0028fac5",
+        "size_in_bytes": 1344
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "a211fceacea4e6621f4316364d2d0b7127c00de3856b8062082f9bc5957ea4db",
+        "sha256_in_prefix": "a211fceacea4e6621f4316364d2d0b7127c00de3856b8062082f9bc5957ea4db",
+        "size_in_bytes": 3204
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "6380eb5ccd0a63402b7f385b0046b52d814fc16dd612011e2f8882a977be03e3",
+        "sha256_in_prefix": "6380eb5ccd0a63402b7f385b0046b52d814fc16dd612011e2f8882a977be03e3",
+        "size_in_bytes": 2009
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging-24.2.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "0a950253178741b44de54191407611268acee407fe432fdf1cc72d710f034862",
+        "sha256_in_prefix": "0a950253178741b44de54191407611268acee407fe432fdf1cc72d710f034862",
+        "size_in_bytes": 82
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "764e136bfbe67552716070dc7f286f40dc3c5773e0481a2628d5ea83e0f62436",
+        "sha256_in_prefix": "764e136bfbe67552716070dc7f286f40dc3c5773e0481a2628d5ea83e0f62436",
+        "size_in_bytes": 494
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "11e1b478d4398d8fb9d4c91810f4f7feb93d5f3606bf1ed92e9c804f00a83aac",
+        "sha256_in_prefix": "11e1b478d4398d8fb9d4c91810f4f7feb93d5f3606bf1ed92e9c804f00a83aac",
+        "size_in_bytes": 479
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_elffile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "38a12a32bc606eceb6c7c6363738a9d1bc47754173f8ab1eb4e455b020fe2933",
+        "sha256_in_prefix": "38a12a32bc606eceb6c7c6363738a9d1bc47754173f8ab1eb4e455b020fe2933",
+        "size_in_bytes": 3378
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_manylinux.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "66240b47c693cff294a347de14cca7ad45d17bbc220cd2d89cd3f3180ffed3e5",
+        "sha256_in_prefix": "66240b47c693cff294a347de14cca7ad45d17bbc220cd2d89cd3f3180ffed3e5",
+        "size_in_bytes": 6434
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_musllinux.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d3068f5b20aeb322fbca75db8f2a2c0ea644f886ad8438cf45d6b5716fcd12a6",
+        "sha256_in_prefix": "d3068f5b20aeb322fbca75db8f2a2c0ea644f886ad8438cf45d6b5716fcd12a6",
+        "size_in_bytes": 3343
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bc266d7f0457544fe72e4ee7940c6b5431a8b99dcd8dccad0f579930fd7ba7c6",
+        "sha256_in_prefix": "bc266d7f0457544fe72e4ee7940c6b5431a8b99dcd8dccad0f579930fd7ba7c6",
+        "size_in_bytes": 9053
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_structures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ed2c82c1ac4ddf81a8da7e959551fb207350e1d7ddc99ccf0fa12f639e702389",
+        "sha256_in_prefix": "ed2c82c1ac4ddf81a8da7e959551fb207350e1d7ddc99ccf0fa12f639e702389",
+        "size_in_bytes": 2759
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/_tokenizer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ae598ac7079a6d1663e4efa0750a12eea5eed94a4c6d52ee106db199722eb7b6",
+        "sha256_in_prefix": "ae598ac7079a6d1663e4efa0750a12eea5eed94a4c6d52ee106db199722eb7b6",
+        "size_in_bytes": 5612
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/markers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "123644d63a56abef61039ce45387611155c1255d9f1b66489a99ed88f885dccb",
+        "sha256_in_prefix": "123644d63a56abef61039ce45387611155c1255d9f1b66489a99ed88f885dccb",
+        "size_in_bytes": 7698
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/metadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f5cece5116c80a49c9fc2c6c0773511065676cbf1a2e7d4b35e5b79613d1d42e",
+        "sha256_in_prefix": "f5cece5116c80a49c9fc2c6c0773511065676cbf1a2e7d4b35e5b79613d1d42e",
+        "size_in_bytes": 18344
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/requirements.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cffb66068c2a9df6b9452d96629a10636f7902642b7b8677663405205406a7f4",
+        "sha256_in_prefix": "cffb66068c2a9df6b9452d96629a10636f7902642b7b8677663405205406a7f4",
+        "size_in_bytes": 2824
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/specifiers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4900460dd443cdca385fdfc9024fc9e4407788aaf7cfd796c48ab1c20504e70f",
+        "sha256_in_prefix": "4900460dd443cdca385fdfc9024fc9e4407788aaf7cfd796c48ab1c20504e70f",
+        "size_in_bytes": 31169
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/tags.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f60284fd04b4743cd651d16c9fcbbf7575039226ec8186de86ad601501c21ae6",
+        "sha256_in_prefix": "f60284fd04b4743cd651d16c9fcbbf7575039226ec8186de86ad601501c21ae6",
+        "size_in_bytes": 14892
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "096f3d0440f04c0e3e9c4927b2f1a52eb177196ed63032e3ae73c281bfc47b06",
+        "sha256_in_prefix": "096f3d0440f04c0e3e9c4927b2f1a52eb177196ed63032e3ae73c281bfc47b06",
+        "size_in_bytes": 4567
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3bcd8c5806b6eb2c802034651431bae19fe7426ee3dd840e1ead128346a09936",
+        "sha256_in_prefix": "3bcd8c5806b6eb2c802034651431bae19fe7426ee3dd840e1ead128346a09936",
+        "size_in_bytes": 15039
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/_elffile.py",
+        "path_type": "hardlink",
+        "sha256": "71f940400904db9b738589aafda0a2ef641f6d3fed9fcf75b4fcdfa5b7873b01",
+        "sha256_in_prefix": "71f940400904db9b738589aafda0a2ef641f6d3fed9fcf75b4fcdfa5b7873b01",
+        "size_in_bytes": 3306
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/_manylinux.py",
+        "path_type": "hardlink",
+        "sha256": "be5e4e0a8cf8931f341f9af05ca7975a397d58d2121a6af86604e94cff6553d7",
+        "sha256_in_prefix": "be5e4e0a8cf8931f341f9af05ca7975a397d58d2121a6af86604e94cff6553d7",
+        "size_in_bytes": 9612
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/_musllinux.py",
+        "path_type": "hardlink",
+        "sha256": "a7d66a35888e22d19e7bc29c64578717f61c76157018774aeabfbc9608b1bc64",
+        "sha256_in_prefix": "a7d66a35888e22d19e7bc29c64578717f61c76157018774aeabfbc9608b1bc64",
+        "size_in_bytes": 2694
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/_parser.py",
+        "path_type": "hardlink",
+        "sha256": "b3f4ef4ef0cd2b436b336401dd529385d58533835cd0fe899e439b925dcc8e93",
+        "sha256_in_prefix": "b3f4ef4ef0cd2b436b336401dd529385d58533835cd0fe899e439b925dcc8e93",
+        "size_in_bytes": 10236
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/_structures.py",
+        "path_type": "hardlink",
+        "sha256": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe",
+        "sha256_in_prefix": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe",
+        "size_in_bytes": 1431
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/_tokenizer.py",
+        "path_type": "hardlink",
+        "sha256": "27abf91fb273bdbfa0f35c69ff640008ac0eecbc47400ea292bc8c53bcd7c0df",
+        "sha256_in_prefix": "27abf91fb273bdbfa0f35c69ff640008ac0eecbc47400ea292bc8c53bcd7c0df",
+        "size_in_bytes": 5273
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/licenses/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "d71e4cd671188dc83011b2edd1d5f0cf6ba48ebd7c0e20b30b4b2b690a89f96c",
+        "sha256_in_prefix": "d71e4cd671188dc83011b2edd1d5f0cf6ba48ebd7c0e20b30b4b2b690a89f96c",
+        "size_in_bytes": 5715
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/licenses/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "573ecc4b93bba87fdfe3a06e4edf1c1f0de83e67299afab73eee2b8003058490",
+        "sha256_in_prefix": "573ecc4b93bba87fdfe3a06e4edf1c1f0de83e67299afab73eee2b8003058490",
+        "size_in_bytes": 2566
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/licenses/__pycache__/_spdx.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3cbe5ad82eb6116b939ff6e2da61c5d3b8ac613815a2a22f953d04f756b0c5c8",
+        "sha256_in_prefix": "3cbe5ad82eb6116b939ff6e2da61c5d3b8ac613815a2a22f953d04f756b0c5c8",
+        "size_in_bytes": 29582
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/licenses/_spdx.py",
+        "path_type": "hardlink",
+        "sha256": "a009b5ced3c5c25b2608a7bb94002cbff38839f4b57160eef5b34191ebbeda7b",
+        "sha256_in_prefix": "a009b5ced3c5c25b2608a7bb94002cbff38839f4b57160eef5b34191ebbeda7b",
+        "size_in_bytes": 48398
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/markers.py",
+        "path_type": "hardlink",
+        "sha256": "73cf5337307b65d198864a2f9ba3d89aa1b21f15e561568b5b9f753c750d283f",
+        "sha256_in_prefix": "73cf5337307b65d198864a2f9ba3d89aa1b21f15e561568b5b9f753c750d283f",
+        "size_in_bytes": 10561
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/metadata.py",
+        "path_type": "hardlink",
+        "sha256": "60989b33b1987b8adef3ed1adce9579864be5c38131283b8b6506ddaadb90678",
+        "sha256_in_prefix": "60989b33b1987b8adef3ed1adce9579864be5c38131283b8b6506ddaadb90678",
+        "size_in_bytes": 34762
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/requirements.py",
+        "path_type": "hardlink",
+        "sha256": "818c9148075bac8c8a0d8ebaba02035108d132fc641f600b8a84e65f7b672faa",
+        "sha256_in_prefix": "818c9148075bac8c8a0d8ebaba02035108d132fc641f600b8a84e65f7b672faa",
+        "size_in_bytes": 2947
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/specifiers.py",
+        "path_type": "hardlink",
+        "sha256": "186d703cd31c2f47cc24eebcbc5e77c0a31dc277de84371a23eafd3694df8a50",
+        "sha256_in_prefix": "186d703cd31c2f47cc24eebcbc5e77c0a31dc277de84371a23eafd3694df8a50",
+        "size_in_bytes": 40074
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/tags.py",
+        "path_type": "hardlink",
+        "sha256": "085aab2730337365cd19ec5eac7fff4fe639230abb59bb185ec88b1112d6c58d",
+        "sha256_in_prefix": "085aab2730337365cd19ec5eac7fff4fe639230abb59bb185ec88b1112d6c58d",
+        "size_in_bytes": 21014
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/utils.py",
+        "path_type": "hardlink",
+        "sha256": "d05dc787d385b9182b8538066549792b6d85bf560fdad665d73ff680eea42620",
+        "sha256_in_prefix": "d05dc787d385b9182b8538066549792b6d85bf560fdad665d73ff680eea42620",
+        "size_in_bytes": 5050
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/packaging/version.py",
+        "path_type": "hardlink",
+        "sha256": "a257f2ba4fc33db7e5364278c0159eb57435edcef8c770c1e74d5d7a052fec36",
+        "sha256_in_prefix": "a257f2ba4fc33db7e5364278c0159eb57435edcef8c770c1e74d5d7a052fec36",
+        "size_in_bytes": 16676
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "ce6b227b4d46d4cb57474c2022fe57a557933bb89daf4596bdf9b12ac296b869",
+        "sha256_in_prefix": "ce6b227b4d46d4cb57474c2022fe57a557933bb89daf4596bdf9b12ac296b869",
+        "size_in_bytes": 11429
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "4c211d76d42ed40efc3acfcc866d8912a718afbca2b7e51849442366d6e99fe8",
+        "sha256_in_prefix": "4c211d76d42ed40efc3acfcc866d8912a718afbca2b7e51849442366d6e99fe8",
+        "size_in_bytes": 1642
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "cc431c46bf4aaf4df1d68cc6c20e6ff4d4012a7de49dda7a2d2a1295583e8e15",
+        "sha256_in_prefix": "cc431c46bf4aaf4df1d68cc6c20e6ff4d4012a7de49dda7a2d2a1295583e8e15",
+        "size_in_bytes": 87
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs-4.2.2.dist-info/licenses/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "29e0fd62e929850e86eb28c3fdccf0cefdf4fa94879011cffb3d0d4bed6d4db6",
+        "sha256_in_prefix": "29e0fd62e929850e86eb28c3fdccf0cefdf4fa94879011cffb3d0d4bed6d4db6",
+        "size_in_bytes": 1089
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "10c184f2a787451f42cc316bf242f7b40f217596678988d705565dd1419358ad",
+        "sha256_in_prefix": "10c184f2a787451f42cc316bf242f7b40f217596678988d705565dd1419358ad",
+        "size_in_bytes": 22225
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "1e7b14407a6205a893c70726c15c3e9c568f755359b5021d8b57960ed23e3332",
+        "sha256_in_prefix": "1e7b14407a6205a893c70726c15c3e9c568f755359b5021d8b57960ed23e3332",
+        "size_in_bytes": 1493
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b467fa553b5c30d28feb008a62f12f7543d4049c4c9361ec774cb5135a98b47e",
+        "sha256_in_prefix": "b467fa553b5c30d28feb008a62f12f7543d4049c4c9361ec774cb5135a98b47e",
+        "size_in_bytes": 16415
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8c2d856030a83bc0b52bfd65cc886c547200fb5032651f471993a46804a5206d",
+        "sha256_in_prefix": "8c2d856030a83bc0b52bfd65cc886c547200fb5032651f471993a46804a5206d",
+        "size_in_bytes": 1333
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/android.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cc1d1ddb005bb1513c540b1f05a91af5409a95f4ac3832e1be87040df34f308e",
+        "sha256_in_prefix": "cc1d1ddb005bb1513c540b1f05a91af5409a95f4ac3832e1be87040df34f308e",
+        "size_in_bytes": 7928
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/api.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ee3c622ca46af72021159aceb01b52edbde90d4162dfe216ad0ac84af79c5cfd",
+        "sha256_in_prefix": "ee3c622ca46af72021159aceb01b52edbde90d4162dfe216ad0ac84af79c5cfd",
+        "size_in_bytes": 10315
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/macos.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "24d44784e5e3776dc6bbf204cbdafb624db7a22312d1667aa463818f1938b07b",
+        "sha256_in_prefix": "24d44784e5e3776dc6bbf204cbdafb624db7a22312d1667aa463818f1938b07b",
+        "size_in_bytes": 6144
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/unix.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bc8eca9acc9475ffd906d0e8aedc3117398ebb787d58a1b284b7f28374de63e1",
+        "sha256_in_prefix": "bc8eca9acc9475ffd906d0e8aedc3117398ebb787d58a1b284b7f28374de63e1",
+        "size_in_bytes": 11039
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4509bc182ec8fecd87128eccfecee440a9ea1dbe24d9e2724811718a7baa2ea6",
+        "sha256_in_prefix": "4509bc182ec8fecd87128eccfecee440a9ea1dbe24d9e2724811718a7baa2ea6",
+        "size_in_bytes": 474
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/__pycache__/windows.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cf736d105e55937fe6f0e2bc6590953130ddc034a70642b6cd8418537f7eaa38",
+        "sha256_in_prefix": "cf736d105e55937fe6f0e2bc6590953130ddc034a70642b6cd8418537f7eaa38",
+        "size_in_bytes": 9201
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/android.py",
+        "path_type": "hardlink",
+        "sha256": "c595d8f49778e963acc53d94ebee47b0db4367e210ab170452b04b977858938a",
+        "sha256_in_prefix": "c595d8f49778e963acc53d94ebee47b0db4367e210ab170452b04b977858938a",
+        "size_in_bytes": 9016
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/api.py",
+        "path_type": "hardlink",
+        "sha256": "40161d51a736782e76d5e93fcb9dee0f50dcabe9495fc22049155de089c2eae7",
+        "sha256_in_prefix": "40161d51a736782e76d5e93fcb9dee0f50dcabe9495fc22049155de089c2eae7",
+        "size_in_bytes": 8996
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/macos.py",
+        "path_type": "hardlink",
+        "sha256": "c1fb6c6ecbeaea767458e4574a20ab64d9111f3fd62ae92d9746ba982ecc1642",
+        "sha256_in_prefix": "c1fb6c6ecbeaea767458e4574a20ab64d9111f3fd62ae92d9746ba982ecc1642",
+        "size_in_bytes": 5580
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/unix.py",
+        "path_type": "hardlink",
+        "sha256": "09c8bd5aab77e5d00cb20e874fd9d11874815b9a1b6f4a51dc01352499ec0978",
+        "sha256_in_prefix": "09c8bd5aab77e5d00cb20e874fd9d11874815b9a1b6f4a51dc01352499ec0978",
+        "size_in_bytes": 10643
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/version.py",
+        "path_type": "hardlink",
+        "sha256": "afb17bead6518e040aceba71fc8d3f64c40e314f8f4bb7869c70fbcc42b7281d",
+        "sha256_in_prefix": "afb17bead6518e040aceba71fc8d3f64c40e314f8f4bb7869c70fbcc42b7281d",
+        "size_in_bytes": 411
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/platformdirs/windows.py",
+        "path_type": "hardlink",
+        "sha256": "205a62a21501c313ed0b39722b036dc725b8264f2169ae96f28e7d99fac35d5a",
+        "sha256_in_prefix": "205a62a21501c313ed0b39722b036dc725b8264f2169ae96f28e7d99fac35d5a",
+        "size_in_bytes": 10125
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "b80816b0d530b8accb4c2211783790984a6e3b61922c2b5ee92f3372ab2742fe",
+        "sha256_in_prefix": "b80816b0d530b8accb4c2211783790984a6e3b61922c2b5ee92f3372ab2742fe",
+        "size_in_bytes": 1072
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "ccf0dc78a98fc0918b5ad67292b1e2c4bed65575a6246cd9d63c914f9942a0f2",
+        "sha256_in_prefix": "ccf0dc78a98fc0918b5ad67292b1e2c4bed65575a6246cd9d63c914f9942a0f2",
+        "size_in_bytes": 8875
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "0cb9f9a451a1e365ac54b4c88662e1da0cb54a72d16a5258fb0abff9d3e1c022",
+        "sha256_in_prefix": "0cb9f9a451a1e365ac54b4c88662e1da0cb54a72d16a5258fb0abff9d3e1c022",
+        "size_in_bytes": 999
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli-2.0.1.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "8cf311fc3ce47385f889c42d9b3f35967358fe402c7e883baf2eeaa11bd82d7c",
+        "sha256_in_prefix": "8cf311fc3ce47385f889c42d9b3f35967358fe402c7e883baf2eeaa11bd82d7c",
+        "size_in_bytes": 81
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "26153057ae830758381efb7551009531d7c2bbe220015f055e6bc353da27c5de",
+        "sha256_in_prefix": "26153057ae830758381efb7551009531d7c2bbe220015f055e6bc353da27c5de",
+        "size_in_bytes": 396
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a5af198b87f0ca012d102c5eea39539220c2f309dfbcd15cbb31b64e7213ee87",
+        "sha256_in_prefix": "a5af198b87f0ca012d102c5eea39539220c2f309dfbcd15cbb31b64e7213ee87",
+        "size_in_bytes": 311
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli/__pycache__/_parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "79ce06c90c4b02c0c7bd286073980612b174dc37d8548fcd25f3ca9c3c496b85",
+        "sha256_in_prefix": "79ce06c90c4b02c0c7bd286073980612b174dc37d8548fcd25f3ca9c3c496b85",
+        "size_in_bytes": 16557
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli/__pycache__/_re.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0a3d3da8fcd30ec7718a6a2df48a100d57145aad030c3dfaa6f9aadcb07c12ce",
+        "sha256_in_prefix": "0a3d3da8fcd30ec7718a6a2df48a100d57145aad030c3dfaa6f9aadcb07c12ce",
+        "size_in_bytes": 2790
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli/__pycache__/_types.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "374d38a21b882fc502fce5bc6279a30306e11a4ba9b5f1ee9fcf2d0460e717ee",
+        "sha256_in_prefix": "374d38a21b882fc502fce5bc6279a30306e11a4ba9b5f1ee9fcf2d0460e717ee",
+        "size_in_bytes": 281
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli/_parser.py",
+        "path_type": "hardlink",
+        "sha256": "83df8435a00b4be07c768918a42bb35056a55a5a20ed3f922183232d9496aed3",
+        "sha256_in_prefix": "83df8435a00b4be07c768918a42bb35056a55a5a20ed3f922183232d9496aed3",
+        "size_in_bytes": 22633
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli/_re.py",
+        "path_type": "hardlink",
+        "sha256": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec",
+        "sha256_in_prefix": "75b8e0e428594f6dca6bdcfd0c73977ddb52a4fc147dd80c5e78fc34ea25cbec",
+        "size_in_bytes": 2943
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli/_types.py",
+        "path_type": "hardlink",
+        "sha256": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74",
+        "sha256_in_prefix": "f864c6d9552a929c7032ace654ee05ef26ca75d21b027b801d77e65907138b74",
+        "size_in_bytes": 254
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/tomli/py.typed",
+        "path_type": "hardlink",
+        "sha256": "f0f8f2675695a10a5156fb7bd66bafbaae6a13e8d315990af862c792175e6e67",
+        "sha256_in_prefix": "f0f8f2675695a10a5156fb7bd66bafbaae6a13e8d315990af862c792175e6e67",
+        "size_in_bytes": 26
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "6163f7987dfb38d6bc320ce2b70b2f02b862bc41126516d552ef1cd43247e758",
+        "sha256_in_prefix": "6163f7987dfb38d6bc320ce2b70b2f02b862bc41126516d552ef1cd43247e758",
+        "size_in_bytes": 1130
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "cf675c1c0a744f08580855390de87cc77d676b312582e8d4cfdb5bb8fd298d21",
+        "sha256_in_prefix": "cf675c1c0a744f08580855390de87cc77d676b312582e8d4cfdb5bb8fd298d21",
+        "size_in_bytes": 3717
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "48a51959582478352275428ceecd78ef77d79ac9dae796e39a2eaf2540282552",
+        "sha256_in_prefix": "48a51959582478352275428ceecd78ef77d79ac9dae796e39a2eaf2540282552",
+        "size_in_bytes": 2402
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "sha256_in_prefix": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "size_in_bytes": 92
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/entry_points.txt",
+        "path_type": "hardlink",
+        "sha256": "aa9ecd43568bb624a0310aa8ea05a57c6a72d08217ce830999e4132e9cea1594",
+        "sha256_in_prefix": "aa9ecd43568bb624a0310aa8ea05a57c6a72d08217ce830999e4132e9cea1594",
+        "size_in_bytes": 48
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard-4.3.0.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "e33dbc021b83a1dc114bf73527f97c1f9d6de50bb07d3b1eb24633971a7a82bb",
+        "sha256_in_prefix": "e33dbc021b83a1dc114bf73527f97c1f9d6de50bb07d3b1eb24633971a7a82bb",
+        "size_in_bytes": 10
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "3a7878c37f1e94f0a3b65714dc963d93787bd0d8ecc5722401f966427f99d056",
+        "sha256_in_prefix": "3a7878c37f1e94f0a3b65714dc963d93787bd0d8ecc5722401f966427f99d056",
+        "size_in_bytes": 2071
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0c4277ee3c064d6050c3237dd51743c8703d38a73408114a812ab7dedc0856f7",
+        "sha256_in_prefix": "0c4277ee3c064d6050c3237dd51743c8703d38a73408114a812ab7dedc0856f7",
+        "size_in_bytes": 1737
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_checkers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6d3f2947be3e36d4fdd8690eb27d9ab4b31b35791c737f1c7a506909aad385b8",
+        "sha256_in_prefix": "6d3f2947be3e36d4fdd8690eb27d9ab4b31b35791c737f1c7a506909aad385b8",
+        "size_in_bytes": 20052
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_config.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9b7720f21325098b0b7977c6c700c862285ebf773851aededcaa64b1c75e28c7",
+        "sha256_in_prefix": "9b7720f21325098b0b7977c6c700c862285ebf773851aededcaa64b1c75e28c7",
+        "size_in_bytes": 3389
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_decorators.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f5018a77798828e80ce7b90749074a86906fa64253ae50d929929358d3cdc9c3",
+        "sha256_in_prefix": "f5018a77798828e80ce7b90749074a86906fa64253ae50d929929358d3cdc9c3",
+        "size_in_bytes": 6990
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_exceptions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e208e10f1a908ece3025501906993e0c62518ee8d5b1925137c5070f251b4bbe",
+        "sha256_in_prefix": "e208e10f1a908ece3025501906993e0c62518ee8d5b1925137c5070f251b4bbe",
+        "size_in_bytes": 2197
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_functions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cfd28849b1719818051aa61d5316ccc4a96eab47d8c794202fc7e39169eb7a00",
+        "sha256_in_prefix": "cfd28849b1719818051aa61d5316ccc4a96eab47d8c794202fc7e39169eb7a00",
+        "size_in_bytes": 7602
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_importhook.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9c2635d966afd95bc89258c54c015e2786b6d6c62499f760845ab9d3b5fa5052",
+        "sha256_in_prefix": "9c2635d966afd95bc89258c54c015e2786b6d6c62499f760845ab9d3b5fa5052",
+        "size_in_bytes": 6771
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_memo.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "41591ff5749dbc42707783d9e5ae70c250578a8c8ec311c5f3368fd58e953108",
+        "sha256_in_prefix": "41591ff5749dbc42707783d9e5ae70c250578a8c8ec311c5f3368fd58e953108",
+        "size_in_bytes": 1543
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_pytest_plugin.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fc2b0a6e165d42f5dc14cd1b5031f03d684a94c9c1afa9f7a3104ad31af1b9dd",
+        "sha256_in_prefix": "fc2b0a6e165d42f5dc14cd1b5031f03d684a94c9c1afa9f7a3104ad31af1b9dd",
+        "size_in_bytes": 3980
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_suppression.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f459c82395f7addbc8acc7a92a86d5de798c611d76dcd0cacada60f85df6d1be",
+        "sha256_in_prefix": "f459c82395f7addbc8acc7a92a86d5de798c611d76dcd0cacada60f85df6d1be",
+        "size_in_bytes": 2632
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_transformer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a14c08883822569fb0f6a8fbad5eaf8171e0b68c401a6242abe49e2d0249f1d0",
+        "sha256_in_prefix": "a14c08883822569fb0f6a8fbad5eaf8171e0b68c401a6242abe49e2d0249f1d0",
+        "size_in_bytes": 27417
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_union_transformer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0c99472ab008891897fb9e34ed26484fabf387670058925a79e82a99125ac0c5",
+        "sha256_in_prefix": "0c99472ab008891897fb9e34ed26484fabf387670058925a79e82a99125ac0c5",
+        "size_in_bytes": 1837
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/__pycache__/_utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "328a6432e9d7ff2da849b2e0828e5fb0e63a5548bb83c49ee17519bd4b63081b",
+        "sha256_in_prefix": "328a6432e9d7ff2da849b2e0828e5fb0e63a5548bb83c49ee17519bd4b63081b",
+        "size_in_bytes": 5079
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_checkers.py",
+        "path_type": "hardlink",
+        "sha256": "251ae02a271d3847c8068344b5e81808422586969df9ad6ed449bb1828f45822",
+        "sha256_in_prefix": "251ae02a271d3847c8068344b5e81808422586969df9ad6ed449bb1828f45822",
+        "size_in_bytes": 31360
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_config.py",
+        "path_type": "hardlink",
+        "sha256": "9c8cfc4300dafa814edcbf4ef3feacaf396677df6949bcb6c0e33859bec5fc1d",
+        "sha256_in_prefix": "9c8cfc4300dafa814edcbf4ef3feacaf396677df6949bcb6c0e33859bec5fc1d",
+        "size_in_bytes": 2846
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_decorators.py",
+        "path_type": "hardlink",
+        "sha256": "bfa76c21e5af3e113118b3ffc1717e4660d4ca365ffc0936f20ee0049fefd3ed",
+        "sha256_in_prefix": "bfa76c21e5af3e113118b3ffc1717e4660d4ca365ffc0936f20ee0049fefd3ed",
+        "size_in_bytes": 9033
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_exceptions.py",
+        "path_type": "hardlink",
+        "sha256": "6483de895f8505de449b0d8469677616f96caf08b8a1cc13d9f54604802d1dc4",
+        "sha256_in_prefix": "6483de895f8505de449b0d8469677616f96caf08b8a1cc13d9f54604802d1dc4",
+        "size_in_bytes": 1121
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_functions.py",
+        "path_type": "hardlink",
+        "sha256": "89b81200a6b9a6d226d5e47d0111b4052a3300524f14d01266a84f57241eaa28",
+        "sha256_in_prefix": "89b81200a6b9a6d226d5e47d0111b4052a3300524f14d01266a84f57241eaa28",
+        "size_in_bytes": 10393
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_importhook.py",
+        "path_type": "hardlink",
+        "sha256": "ba08c20ef15c756314ed4ba0aa5246f7522954da44231b51afef7db3487593b3",
+        "sha256_in_prefix": "ba08c20ef15c756314ed4ba0aa5246f7522954da44231b51afef7db3487593b3",
+        "size_in_bytes": 6389
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_memo.py",
+        "path_type": "hardlink",
+        "sha256": "d63b9057fbf19c3d8960a6d2ade6e242e8f8a0a1f3ea7ebbbfda5803e0822128",
+        "sha256_in_prefix": "d63b9057fbf19c3d8960a6d2ade6e242e8f8a0a1f3ea7ebbbfda5803e0822128",
+        "size_in_bytes": 1303
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_pytest_plugin.py",
+        "path_type": "hardlink",
+        "sha256": "f9f712aa4bf9e2b21f205f290dabd8e5840f923e0e5fc18cb7f94bec24120f82",
+        "sha256_in_prefix": "f9f712aa4bf9e2b21f205f290dabd8e5840f923e0e5fc18cb7f94bec24120f82",
+        "size_in_bytes": 4416
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_suppression.py",
+        "path_type": "hardlink",
+        "sha256": "5507f3c5cc086eede27f47fb54190a33b86460e03bb4d170f5aee3301b26320e",
+        "sha256_in_prefix": "5507f3c5cc086eede27f47fb54190a33b86460e03bb4d170f5aee3301b26320e",
+        "size_in_bytes": 2266
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_transformer.py",
+        "path_type": "hardlink",
+        "sha256": "f476bbfd085dc285278bfea1bdd63e8596ee11eae0a301eb34bdafcc721a9056",
+        "sha256_in_prefix": "f476bbfd085dc285278bfea1bdd63e8596ee11eae0a301eb34bdafcc721a9056",
+        "size_in_bytes": 44937
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_union_transformer.py",
+        "path_type": "hardlink",
+        "sha256": "bffe36afbfba1ee457d92a05c27c89f84e4f9715e955e5093c9475f8753da92a",
+        "sha256_in_prefix": "bffe36afbfba1ee457d92a05c27c89f84e4f9715e955e5093c9475f8753da92a",
+        "size_in_bytes": 1354
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/_utils.py",
+        "path_type": "hardlink",
+        "sha256": "e4784ed6b3e7e5fd4ceb29a454012fed79a5cf5717fa3d0e9d3325c87aaaad1f",
+        "sha256_in_prefix": "e4784ed6b3e7e5fd4ceb29a454012fed79a5cf5717fa3d0e9d3325c87aaaad1f",
+        "size_in_bytes": 5270
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typeguard/py.typed",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf",
+        "sha256_in_prefix": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf",
+        "size_in_bytes": 13936
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "05e51021af1c9d86eb8d6c7e37c4cece733d5065b91a6d8389c5690ed440f16d",
+        "sha256_in_prefix": "05e51021af1c9d86eb8d6c7e37c4cece733d5065b91a6d8389c5690ed440f16d",
+        "size_in_bytes": 3018
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "7710002d81971e632aa6a2fc33dc5d74aaf5d7caae22040a65d3e31503b05ee9",
+        "sha256_in_prefix": "7710002d81971e632aa6a2fc33dc5d74aaf5d7caae22040a65d3e31503b05ee9",
+        "size_in_bytes": 571
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typing_extensions-4.12.2.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "1196c6921ec87b83e865f450f08d19b8ff5592537f4ef719e83484e546abe33e",
+        "sha256_in_prefix": "1196c6921ec87b83e865f450f08d19b8ff5592537f4ef719e83484e546abe33e",
+        "size_in_bytes": 81
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/typing_extensions.py",
+        "path_type": "hardlink",
+        "sha256": "8307a4a721bd0d51b797158a5f89e2f2eee793759ee6c946f7c980f45dc3250c",
+        "sha256_in_prefix": "8307a4a721bd0d51b797158a5f89e2f2eee793759ee6c946f7c980f45dc3250c",
+        "size_in_bytes": 134451
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/LICENSE.txt",
+        "path_type": "hardlink",
+        "sha256": "30c23618679108f3e8ea1d2a658c7ca417bdfc891c98ef1a89fa4ff0c9828654",
+        "sha256_in_prefix": "30c23618679108f3e8ea1d2a658c7ca417bdfc891c98ef1a89fa4ff0c9828654",
+        "size_in_bytes": 1107
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "59bac22b00a59d3e5608a56b8cf8efc43831a36b72792ee4389c9cd4669c7841",
+        "sha256_in_prefix": "59bac22b00a59d3e5608a56b8cf8efc43831a36b72792ee4389c9cd4669c7841",
+        "size_in_bytes": 2153
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "783e654742611af88cd9f00bf01a431a219db536556e63ff981c7bd673070ac9",
+        "sha256_in_prefix": "783e654742611af88cd9f00bf01a431a219db536556e63ff981c7bd673070ac9",
+        "size_in_bytes": 4557
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "1196c6921ec87b83e865f450f08d19b8ff5592537f4ef719e83484e546abe33e",
+        "sha256_in_prefix": "1196c6921ec87b83e865f450f08d19b8ff5592537f4ef719e83484e546abe33e",
+        "size_in_bytes": 81
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel-0.43.0.dist-info/entry_points.txt",
+        "path_type": "hardlink",
+        "sha256": "ad363505b90f1e1906326e10dc5d29233241cd6da4331a06d68ae27dfbc6740d",
+        "sha256_in_prefix": "ad363505b90f1e1906326e10dc5d29233241cd6da4331a06d68ae27dfbc6740d",
+        "size_in_bytes": 104
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "0fa8e11f4d1e3336e0ad718078ec157c3e62fa508030cc9cb86d4bd2eb1e0e5a",
+        "sha256_in_prefix": "0fa8e11f4d1e3336e0ad718078ec157c3e62fa508030cc9cb86d4bd2eb1e0e5a",
+        "size_in_bytes": 59
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "3643149ee4c219c3a4818d0804b8010950bf04619c58e471d8af236064b5d941",
+        "sha256_in_prefix": "3643149ee4c219c3a4818d0804b8010950bf04619c58e471d8af236064b5d941",
+        "size_in_bytes": 455
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5f11d17cfc651a92883bf4d96663ef1e0be23c467e2d92bef6db1f81999c2bbe",
+        "sha256_in_prefix": "5f11d17cfc651a92883bf4d96663ef1e0be23c467e2d92bef6db1f81999c2bbe",
+        "size_in_bytes": 218
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e6101bbf7c23a990375622ed2c401fbdd8fe7547016ac1df548c6b6b57643306",
+        "sha256_in_prefix": "e6101bbf7c23a990375622ed2c401fbdd8fe7547016ac1df548c6b6b57643306",
+        "size_in_bytes": 610
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/_setuptools_logging.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b8f66e8232c226ce00b097a027ae971166aaf61112a5649babfe289c6bd5e71a",
+        "sha256_in_prefix": "b8f66e8232c226ce00b097a027ae971166aaf61112a5649babfe289c6bd5e71a",
+        "size_in_bytes": 922
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/bdist_wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e830c836c81692479dcf1b281674ecade3a1e63c180c7829359922219d1e69f7",
+        "sha256_in_prefix": "e830c836c81692479dcf1b281674ecade3a1e63c180c7829359922219d1e69f7",
+        "size_in_bytes": 14171
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/macosx_libfile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "545248f28e8fd011e8cde41762dd52341832a53cc8439409d8d51682ac2be90b",
+        "sha256_in_prefix": "545248f28e8fd011e8cde41762dd52341832a53cc8439409d8d51682ac2be90b",
+        "size_in_bytes": 10026
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/metadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "81cd430741223502dcee7a9fdbe12277d2bc566b0f3d9d775ec8b1641cef3088",
+        "sha256_in_prefix": "81cd430741223502dcee7a9fdbe12277d2bc566b0f3d9d775ec8b1641cef3088",
+        "size_in_bytes": 5736
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2fc6d6043d33c09acd5364412a65318b80b4cadcc729d2805b01c620a4d40569",
+        "sha256_in_prefix": "2fc6d6043d33c09acd5364412a65318b80b4cadcc729d2805b01c620a4d40569",
+        "size_in_bytes": 844
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/__pycache__/wheelfile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c0529626ebbfc2f77525fd083c86492548d67c0cf7aba5f832b30bf21f9b652d",
+        "sha256_in_prefix": "c0529626ebbfc2f77525fd083c86492548d67c0cf7aba5f832b30bf21f9b652d",
+        "size_in_bytes": 5600
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/_setuptools_logging.py",
+        "path_type": "hardlink",
+        "sha256": "3680a78c9e03144678e44a3ed817572ec5890b01a46a2b75b69ff5ee96a5795c",
+        "sha256_in_prefix": "3680a78c9e03144678e44a3ed817572ec5890b01a46a2b75b69ff5ee96a5795c",
+        "size_in_bytes": 746
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/bdist_wheel.py",
+        "path_type": "hardlink",
+        "sha256": "38a272a7d13cdf5cc9af1a117e633d0203a30721b5081fa9cc5e645d016668a9",
+        "sha256_in_prefix": "38a272a7d13cdf5cc9af1a117e633d0203a30721b5081fa9cc5e645d016668a9",
+        "size_in_bytes": 20938
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "7813619cfc164ed74a0091f2efb96fcfb80e43912edc66af1ae817c614ac9fe5",
+        "sha256_in_prefix": "7813619cfc164ed74a0091f2efb96fcfb80e43912edc66af1ae817c614ac9fe5",
+        "size_in_bytes": 4264
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9b58b627d4c0b26d929e29ed1912caab82b0f178c3dcfb7cfb10cc48035cb4df",
+        "sha256_in_prefix": "9b58b627d4c0b26d929e29ed1912caab82b0f178c3dcfb7cfb10cc48035cb4df",
+        "size_in_bytes": 4513
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/convert.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f7659a7212b666c19b4663d638688b3b47aa6d480bfe0d9dd101f5b277601b38",
+        "sha256_in_prefix": "f7659a7212b666c19b4663d638688b3b47aa6d480bfe0d9dd101f5b277601b38",
+        "size_in_bytes": 6314
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/pack.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e3944fb1a09eb4bbf8839cbd176704a95e2fa1b9d279723874e57c3b9544e787",
+        "sha256_in_prefix": "e3944fb1a09eb4bbf8839cbd176704a95e2fa1b9d279723874e57c3b9544e787",
+        "size_in_bytes": 3091
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/tags.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a4647f4c4bcf9ce661b8a0b120b237605e65f40446547fe698de7792529beb18",
+        "sha256_in_prefix": "a4647f4c4bcf9ce661b8a0b120b237605e65f40446547fe698de7792529beb18",
+        "size_in_bytes": 3804
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/__pycache__/unpack.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7db835ff85c1185ee1da341074f55dc8c80444e9e79c16be892181374e0b05dc",
+        "sha256_in_prefix": "7db835ff85c1185ee1da341074f55dc8c80444e9e79c16be892181374e0b05dc",
+        "size_in_bytes": 1062
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/convert.py",
+        "path_type": "hardlink",
+        "sha256": "a897296062aa75fc353fa05e9603751e7fecb8d80ce9bbf211616565eb925b1d",
+        "sha256_in_prefix": "a897296062aa75fc353fa05e9603751e7fecb8d80ce9bbf211616565eb925b1d",
+        "size_in_bytes": 9439
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/pack.py",
+        "path_type": "hardlink",
+        "sha256": "08015c1dd055ba5bec1d82659dd2953bb28c23d26a053673e628b43cac7108eb",
+        "sha256_in_prefix": "08015c1dd055ba5bec1d82659dd2953bb28c23d26a053673e628b43cac7108eb",
+        "size_in_bytes": 3103
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/tags.py",
+        "path_type": "hardlink",
+        "sha256": "947c3e2da5ab912e49cbfa96730fbaa528de34ceb20230e7a8a2371392534c25",
+        "sha256_in_prefix": "947c3e2da5ab912e49cbfa96730fbaa528de34ceb20230e7a8a2371392534c25",
+        "size_in_bytes": 4760
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/cli/unpack.py",
+        "path_type": "hardlink",
+        "sha256": "63f27bca7c4f4a81454d3ec7d1f3206c195512bc320c670e6e099ee4c06ecf9f",
+        "sha256_in_prefix": "63f27bca7c4f4a81454d3ec7d1f3206c195512bc320c670e6e099ee4c06ecf9f",
+        "size_in_bytes": 1021
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/macosx_libfile.py",
+        "path_type": "hardlink",
+        "sha256": "1e75ba38f74df7dde9b12b6fc25e3dc6dc76930ee1a156deea7bf099ff16b0a2",
+        "sha256_in_prefix": "1e75ba38f74df7dde9b12b6fc25e3dc6dc76930ee1a156deea7bf099ff16b0a2",
+        "size_in_bytes": 16103
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/metadata.py",
+        "path_type": "hardlink",
+        "sha256": "abec420aa4802bb1f3c99c4af40ebf1c05a686a4b5a01e01170d7eac74310624",
+        "sha256_in_prefix": "abec420aa4802bb1f3c99c4af40ebf1c05a686a4b5a01e01170d7eac74310624",
+        "size_in_bytes": 5884
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/util.py",
+        "path_type": "hardlink",
+        "sha256": "7b48e99ec6db33d42169a312c9aa7efd9814c5cc70a722c393a44772b76e3cb8",
+        "sha256_in_prefix": "7b48e99ec6db33d42169a312c9aa7efd9814c5cc70a722c393a44772b76e3cb8",
+        "size_in_bytes": 621
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6d780c6040389fb0bca08c8687bc0e3281681879bbf3398f493bbcd43a756e35",
+        "sha256_in_prefix": "6d780c6040389fb0bca08c8687bc0e3281681879bbf3398f493bbcd43a756e35",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6c243b6414a13f582eaf8c884c7fc48bcd739b0a6ca8cbb05039f9f6e02e14fd",
+        "sha256_in_prefix": "6c243b6414a13f582eaf8c884c7fc48bcd739b0a6ca8cbb05039f9f6e02e14fd",
+        "size_in_bytes": 164
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_elffile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "715e1ea76d16fcda37c78cae101ce32fc5396890d16c90bddceacd73d155c4fb",
+        "sha256_in_prefix": "715e1ea76d16fcda37c78cae101ce32fc5396890d16c90bddceacd73d155c4fb",
+        "size_in_bytes": 3334
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_manylinux.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4bf35674ce99ef6fe6995c9a4681029498f7c472cdaa7d51fd7f76c7424f8a32",
+        "sha256_in_prefix": "4bf35674ce99ef6fe6995c9a4681029498f7c472cdaa7d51fd7f76c7424f8a32",
+        "size_in_bytes": 6381
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_musllinux.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b750da7f416ad027c0afc05340a043b27eea61af9053a1ba88f6142f02081fab",
+        "sha256_in_prefix": "b750da7f416ad027c0afc05340a043b27eea61af9053a1ba88f6142f02081fab",
+        "size_in_bytes": 3296
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3e81aadf1b859127fadb1e4cf3cf2ae45b803743965d1b8be9e3e73198a9c4c5",
+        "sha256_in_prefix": "3e81aadf1b859127fadb1e4cf3cf2ae45b803743965d1b8be9e3e73198a9c4c5",
+        "size_in_bytes": 8965
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_structures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7d5a55ef7813c1db6e3dda73415275f7eb0724e20ccabfd05daed71d085e2e93",
+        "sha256_in_prefix": "7d5a55ef7813c1db6e3dda73415275f7eb0724e20ccabfd05daed71d085e2e93",
+        "size_in_bytes": 2774
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/_tokenizer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c3ace620bb47afee7d9a69a91dea269a27fb05a4b6f233f239ce043051f0cb56",
+        "sha256_in_prefix": "c3ace620bb47afee7d9a69a91dea269a27fb05a4b6f233f239ce043051f0cb56",
+        "size_in_bytes": 5671
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/markers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "77814c1ffa75df781099d825700798e1ddd53a0dc849c30328999e94af88bc65",
+        "sha256_in_prefix": "77814c1ffa75df781099d825700798e1ddd53a0dc849c30328999e94af88bc65",
+        "size_in_bytes": 6961
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/requirements.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9880e6ed10690a9f9b5f444b2b7f27584c1a646cd7b9b8338cd6265fc20f0856",
+        "sha256_in_prefix": "9880e6ed10690a9f9b5f444b2b7f27584c1a646cd7b9b8338cd6265fc20f0856",
+        "size_in_bytes": 2814
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/specifiers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8694c25d2ce4429e41610f70e80b1cece20f1789e1b519c00311f981922254c8",
+        "sha256_in_prefix": "8694c25d2ce4429e41610f70e80b1cece20f1789e1b519c00311f981922254c8",
+        "size_in_bytes": 31015
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/tags.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8ca83ad0f2d87988e1e4de11bbea714795aafea16264b913de6e471e6239e86b",
+        "sha256_in_prefix": "8ca83ad0f2d87988e1e4de11bbea714795aafea16264b913de6e471e6239e86b",
+        "size_in_bytes": 13856
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ea003a83deba37461f4f5288a45e07413ad6ac045277c4f9f7d0a8b971e2df50",
+        "sha256_in_prefix": "ea003a83deba37461f4f5288a45e07413ad6ac045277c4f9f7d0a8b971e2df50",
+        "size_in_bytes": 4572
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "828b4837094cb6be6c49f570e417c63d0602a049a4f8e1757121c6a718dfccc1",
+        "sha256_in_prefix": "828b4837094cb6be6c49f570e417c63d0602a049a4f8e1757121c6a718dfccc1",
+        "size_in_bytes": 14292
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_elffile.py",
+        "path_type": "hardlink",
+        "sha256": "85b98af0e0fa67b7d8ea1c229c7114703d5bcbb73390688d62eed28671449369",
+        "sha256_in_prefix": "85b98af0e0fa67b7d8ea1c229c7114703d5bcbb73390688d62eed28671449369",
+        "size_in_bytes": 3266
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_manylinux.py",
+        "path_type": "hardlink",
+        "sha256": "3fbb1d479ffb5c1634f4b55860f8479b274c2482303d75ac878a2593be14ba3e",
+        "sha256_in_prefix": "3fbb1d479ffb5c1634f4b55860f8479b274c2482303d75ac878a2593be14ba3e",
+        "size_in_bytes": 9588
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_musllinux.py",
+        "path_type": "hardlink",
+        "sha256": "cf5b3c4e8da1434be99ff77e3b68b9ab11b010af1698694bb7777fdba57b35e6",
+        "sha256_in_prefix": "cf5b3c4e8da1434be99ff77e3b68b9ab11b010af1698694bb7777fdba57b35e6",
+        "size_in_bytes": 2674
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_parser.py",
+        "path_type": "hardlink",
+        "sha256": "e2d4f87a64a5daa4da53b553404d576bda358cc3c2b017b3b18071c8d31437eb",
+        "sha256_in_prefix": "e2d4f87a64a5daa4da53b553404d576bda358cc3c2b017b3b18071c8d31437eb",
+        "size_in_bytes": 10347
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_structures.py",
+        "path_type": "hardlink",
+        "sha256": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe",
+        "sha256_in_prefix": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe",
+        "size_in_bytes": 1431
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/_tokenizer.py",
+        "path_type": "hardlink",
+        "sha256": "6a50ad6f05e138502614667a050fb0093485a11009db3fb2b087fbfff31327f9",
+        "sha256_in_prefix": "6a50ad6f05e138502614667a050fb0093485a11009db3fb2b087fbfff31327f9",
+        "size_in_bytes": 5292
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/markers.py",
+        "path_type": "hardlink",
+        "sha256": "fd348f2350612583bb069f40cd398743122a1c45576938e60e1f46fb0f2accf0",
+        "sha256_in_prefix": "fd348f2350612583bb069f40cd398743122a1c45576938e60e1f46fb0f2accf0",
+        "size_in_bytes": 8232
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/requirements.py",
+        "path_type": "hardlink",
+        "sha256": "760a01795a6b3eed9813a43c9c67f038f4e30131db45afd918bc978451259fa4",
+        "sha256_in_prefix": "760a01795a6b3eed9813a43c9c67f038f4e30131db45afd918bc978451259fa4",
+        "size_in_bytes": 2933
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/specifiers.py",
+        "path_type": "hardlink",
+        "sha256": "2164add12acb48fef685e5a1002f142f4786bdab3b5c84078ea8958957e63ca1",
+        "sha256_in_prefix": "2164add12acb48fef685e5a1002f142f4786bdab3b5c84078ea8958957e63ca1",
+        "size_in_bytes": 39778
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/tags.py",
+        "path_type": "hardlink",
+        "sha256": "7de7475e2387901c4d6535e8b57bfcb973e630553d69ef93281ba38181e281c0",
+        "sha256_in_prefix": "7de7475e2387901c4d6535e8b57bfcb973e630553d69ef93281ba38181e281c0",
+        "size_in_bytes": 18950
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/utils.py",
+        "path_type": "hardlink",
+        "sha256": "5e07663f7cb1f7ec101058ceecebcc8fd46311fe49951e4714547af6fed243d1",
+        "sha256_in_prefix": "5e07663f7cb1f7ec101058ceecebcc8fd46311fe49951e4714547af6fed243d1",
+        "size_in_bytes": 5268
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/packaging/version.py",
+        "path_type": "hardlink",
+        "sha256": "3c525a6190f1060cb191f6211f7490c38a9f13d202096ad39a2b6fab5e32ddbb",
+        "sha256_in_prefix": "3c525a6190f1060cb191f6211f7490c38a9f13d202096ad39a2b6fab5e32ddbb",
+        "size_in_bytes": 16234
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/vendored/vendor.txt",
+        "path_type": "hardlink",
+        "sha256": "67610d8c1d62e69adf7b3f0274cd5276bddce99c6fdab451a253292e60677001",
+        "sha256_in_prefix": "67610d8c1d62e69adf7b3f0274cd5276bddce99c6fdab451a253292e60677001",
+        "size_in_bytes": 16
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/wheel/wheelfile.py",
+        "path_type": "hardlink",
+        "sha256": "0ed2435a864cbe7061e2578d3033c63a9ad053d77f769eaaf8c995d14fbee317",
+        "sha256_in_prefix": "0ed2435a864cbe7061e2578d3033c63a9ad053d77f769eaaf8c995d14fbee317",
+        "size_in_bytes": 7694
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/INSTALLER",
+        "path_type": "hardlink",
+        "sha256": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "sha256_in_prefix": "d0edee15f91b406f3f99726e44eb990be6e34fd0345b52b910c568e0eef6a2a8",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "sha256_in_prefix": "86da0f01aeae46348a3c3d465195dc1ceccde79f79e87769a64b8da04b2a4741",
+        "size_in_bytes": 1023
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "508ae4fe43081c64b0b0a2828588b3a8cc3430c6693d1676662569400b0dfdb1",
+        "sha256_in_prefix": "508ae4fe43081c64b0b0a2828588b3a8cc3430c6693d1676662569400b0dfdb1",
+        "size_in_bytes": 3575
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "f316f2e03fd9ade7ebbc0b154706848e2bb8fd568b90935109f0d8e3ce2b9bfe",
+        "sha256_in_prefix": "f316f2e03fd9ade7ebbc0b154706848e2bb8fd568b90935109f0d8e3ce2b9bfe",
+        "size_in_bytes": 1039
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/REQUESTED",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "sha256_in_prefix": "189eedfe4581172c1b6a02b97a8f48a14c0b5baa3239e4ca990fbd8871553714",
+        "size_in_bytes": 92
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp-3.19.2.dist-info/top_level.txt",
+        "path_type": "hardlink",
+        "sha256": "8806dda121df686a817d56f65ee47d26a4901c2a0eb0eb46eb2f42fcb4a9a85c",
+        "sha256_in_prefix": "8806dda121df686a817d56f65ee47d26a4901c2a0eb0eb46eb2f42fcb4a9a85c",
+        "size_in_bytes": 5
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "42e235834d06e1f440706b7e1ea6d5d285889264a079d086198b071d8ccd6bc0",
+        "sha256_in_prefix": "42e235834d06e1f440706b7e1ea6d5d285889264a079d086198b071d8ccd6bc0",
+        "size_in_bytes": 13412
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6b63757838fdd05127c6f67e242a98fb998d063f0dc2c4d79f3499306780b8f0",
+        "sha256_in_prefix": "6b63757838fdd05127c6f67e242a98fb998d063f0dc2c4d79f3499306780b8f0",
+        "size_in_bytes": 16227
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp/__pycache__/glob.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c4f00a6290d08b1e1ec58352d6a7e43888f7313e541a99a761b4965205f822f9",
+        "sha256_in_prefix": "c4f00a6290d08b1e1ec58352d6a7e43888f7313e541a99a761b4965205f822f9",
+        "size_in_bytes": 3929
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp/compat/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp/compat/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "613a66fd2b828aa00b26ecd1de4ed83974a33405abdb3973ee8a520c537e72a0",
+        "sha256_in_prefix": "613a66fd2b828aa00b26ecd1de4ed83974a33405abdb3973ee8a520c537e72a0",
+        "size_in_bytes": 151
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp/compat/__pycache__/py310.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cdd5477780fd539e23b23690dba76f6afc10b76764f77d7557385c7436cb16f3",
+        "sha256_in_prefix": "cdd5477780fd539e23b23690dba76f6afc10b76764f77d7557385c7436cb16f3",
+        "size_in_bytes": 384
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp/compat/py310.py",
+        "path_type": "hardlink",
+        "sha256": "799a645b4cd1b6e9e484487c8e35f780219edb67a6a0a081270ef666de119210",
+        "sha256_in_prefix": "799a645b4cd1b6e9e484487c8e35f780219edb67a6a0a081270ef666de119210",
+        "size_in_bytes": 219
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/_vendor/zipp/glob.py",
+        "path_type": "hardlink",
+        "sha256": "7ad5a99df1284727d4beb52c8bab13886984aef3f07ba1f363aa53f2383f9542",
+        "sha256_in_prefix": "7ad5a99df1284727d4beb52c8bab13886984aef3f07ba1f363aa53f2383f9542",
+        "size_in_bytes": 3082
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/archive_util.py",
+        "path_type": "hardlink",
+        "sha256": "4e5ffae21493b5ce32f31ef16bdf2b15551b1b6e2802ba63ccb0181983f6fec2",
+        "sha256_in_prefix": "4e5ffae21493b5ce32f31ef16bdf2b15551b1b6e2802ba63ccb0181983f6fec2",
+        "size_in_bytes": 7356
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/build_meta.py",
+        "path_type": "hardlink",
+        "sha256": "aebcbe2e8c2abd616cc46e909b94167ad1c919e113cd1762439f9bb386ce923a",
+        "sha256_in_prefix": "aebcbe2e8c2abd616cc46e909b94167ad1c919e113cd1762439f9bb386ce923a",
+        "size_in_bytes": 20446
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/cli-32.exe",
+        "path_type": "hardlink",
+        "sha256": "32acc1bc543116cbe2cff10cb867772df2f254ff2634c870aef0b46c4b696fdb",
+        "sha256_in_prefix": "32acc1bc543116cbe2cff10cb867772df2f254ff2634c870aef0b46c4b696fdb",
+        "size_in_bytes": 11776
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/cli-64.exe",
+        "path_type": "hardlink",
+        "sha256": "bbb3de5707629e6a60a0c238cd477b28f07f0066982fda953fa6fcec39073a4a",
+        "sha256_in_prefix": "bbb3de5707629e6a60a0c238cd477b28f07f0066982fda953fa6fcec39073a4a",
+        "size_in_bytes": 14336
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/cli-arm64.exe",
+        "path_type": "hardlink",
+        "sha256": "b9a7d08da880dfac8bcf548eba4b06fb59b6f09b17d33148a0f6618328926c61",
+        "sha256_in_prefix": "b9a7d08da880dfac8bcf548eba4b06fb59b6f09b17d33148a0f6618328926c61",
+        "size_in_bytes": 13824
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/cli.exe",
+        "path_type": "hardlink",
+        "sha256": "32acc1bc543116cbe2cff10cb867772df2f254ff2634c870aef0b46c4b696fdb",
+        "sha256_in_prefix": "32acc1bc543116cbe2cff10cb867772df2f254ff2634c870aef0b46c4b696fdb",
+        "size_in_bytes": 11776
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "c1d4ab94d4743fa9c2cfdfe816d08088091e14932c65ad633dca574f9ddfd123",
+        "sha256_in_prefix": "c1d4ab94d4743fa9c2cfdfe816d08088091e14932c65ad633dca574f9ddfd123",
+        "size_in_bytes": 803
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3e436650c00599d187c5a9864399855265a6e921d60feea3d302f6e98252ff39",
+        "sha256_in_prefix": "3e436650c00599d187c5a9864399855265a6e921d60feea3d302f6e98252ff39",
+        "size_in_bytes": 379
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/_requirestxt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f5afa5361a5efd9eb706a11f27a01e3c6c6012534b357a0861fb096e8f4ea633",
+        "sha256_in_prefix": "f5afa5361a5efd9eb706a11f27a01e3c6c6012534b357a0861fb096e8f4ea633",
+        "size_in_bytes": 4587
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/alias.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d2c53452ab01c9e1529ce00ca905bd14e2b5466d6ab7c2c3b78e18c56e245dec",
+        "sha256_in_prefix": "d2c53452ab01c9e1529ce00ca905bd14e2b5466d6ab7c2c3b78e18c56e245dec",
+        "size_in_bytes": 2344
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/bdist_egg.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9e3247fbc484afce84ec04daf114679685616900a6f5f1add3e9dec2db147706",
+        "sha256_in_prefix": "9e3247fbc484afce84ec04daf114679685616900a6f5f1add3e9dec2db147706",
+        "size_in_bytes": 13575
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/bdist_rpm.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "382e29f0872f7ffc44040631780fead93a3d7ba67cc91a876532c1c6411c0f43",
+        "sha256_in_prefix": "382e29f0872f7ffc44040631780fead93a3d7ba67cc91a876532c1c6411c0f43",
+        "size_in_bytes": 1764
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/bdist_wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "39f0e65e9cc8d581ea89a359ccd900a6ec33860c5267a6979775cf89cd239177",
+        "sha256_in_prefix": "39f0e65e9cc8d581ea89a359ccd900a6ec33860c5267a6979775cf89cd239177",
+        "size_in_bytes": 15287
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/build.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eec4ddb4152782fac7723db9643831c3fa49b7bb26f2f0f223e06271b50df60a",
+        "sha256_in_prefix": "eec4ddb4152782fac7723db9643831c3fa49b7bb26f2f0f223e06271b50df60a",
+        "size_in_bytes": 5272
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/build_clib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "cd4b8a0c176a06a863de9838cbfeac6b9c0d13c92b68f2e757bb70f1397b5290",
+        "sha256_in_prefix": "cd4b8a0c176a06a863de9838cbfeac6b9c0d13c92b68f2e757bb70f1397b5290",
+        "size_in_bytes": 2484
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/build_ext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "083711f8a98da3c1c0dc20c98479a99db270d8f00d752cf342badc31020ec45e",
+        "sha256_in_prefix": "083711f8a98da3c1c0dc20c98479a99db270d8f00d752cf342badc31020ec45e",
+        "size_in_bytes": 13825
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/build_py.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5470c8761261c4f39920eb94adddf9967880835c239ffff2940c23d228c11fad",
+        "sha256_in_prefix": "5470c8761261c4f39920eb94adddf9967880835c239ffff2940c23d228c11fad",
+        "size_in_bytes": 14765
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/develop.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "29252610e07396cc59002749b00ea202bace2a4bb196fdb7bcb0f59e61c4662d",
+        "sha256_in_prefix": "29252610e07396cc59002749b00ea202bace2a4bb196fdb7bcb0f59e61c4662d",
+        "size_in_bytes": 6073
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/dist_info.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "00d4415782f0d9d9787bfb61155eee606052b344991be9f598cfc114a2bbb66e",
+        "sha256_in_prefix": "00d4415782f0d9d9787bfb61155eee606052b344991be9f598cfc114a2bbb66e",
+        "size_in_bytes": 3234
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/easy_install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fc27b63c6b4962c05af754961184216862cd39e78956e5a6f35d6d1190ac6968",
+        "sha256_in_prefix": "fc27b63c6b4962c05af754961184216862cd39e78956e5a6f35d6d1190ac6968",
+        "size_in_bytes": 64979
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/editable_wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "40c9bfc8135ac2ffbaeea55c357dd5fa07a468d1b6a40dc8181cf439f24498ea",
+        "sha256_in_prefix": "40c9bfc8135ac2ffbaeea55c357dd5fa07a468d1b6a40dc8181cf439f24498ea",
+        "size_in_bytes": 35083
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/egg_info.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9e0776728eb6820bb31f9a0490e42bf94663bacc2904a0ab9b8bad28eb476501",
+        "sha256_in_prefix": "9e0776728eb6820bb31f9a0490e42bf94663bacc2904a0ab9b8bad28eb476501",
+        "size_in_bytes": 22351
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9e4d29ea89168a007de3359665469c0b2f9b49f8f61edf59e4fa034d08a9d656",
+        "sha256_in_prefix": "9e4d29ea89168a007de3359665469c0b2f9b49f8f61edf59e4fa034d08a9d656",
+        "size_in_bytes": 5385
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/install_egg_info.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4183e905675cc9eec4cc04e75eea2b29095383934dc5dacc8975635a9f080ab1",
+        "sha256_in_prefix": "4183e905675cc9eec4cc04e75eea2b29095383934dc5dacc8975635a9f080ab1",
+        "size_in_bytes": 2362
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/install_lib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b2ee54a7d26b9c5264ab6a0f0c53664d35b417386dec85570148982676245714",
+        "sha256_in_prefix": "b2ee54a7d26b9c5264ab6a0f0c53664d35b417386dec85570148982676245714",
+        "size_in_bytes": 4380
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/install_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6196b409cad47b9783d31f7307c3362ba0b827d82c8114f3edf53f58b46e30d7",
+        "sha256_in_prefix": "6196b409cad47b9783d31f7307c3362ba0b827d82c8114f3edf53f58b46e30d7",
+        "size_in_bytes": 2546
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/rotate.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a2cc2c9259377bdbe2118cfaf3c90556fa54a03a156c033210ca1d8e7541a0e6",
+        "sha256_in_prefix": "a2cc2c9259377bdbe2118cfaf3c90556fa54a03a156c033210ca1d8e7541a0e6",
+        "size_in_bytes": 2610
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/saveopts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3a25555fd2f8d3700803c77e573041a13726d0085c432e4050f23b40f4d841be",
+        "sha256_in_prefix": "3a25555fd2f8d3700803c77e573041a13726d0085c432e4050f23b40f4d841be",
+        "size_in_bytes": 890
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/sdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b08e26055723a3625cea15c91a51f923630052e5e72961a2928e61f781e5eafb",
+        "sha256_in_prefix": "b08e26055723a3625cea15c91a51f923630052e5e72961a2928e61f781e5eafb",
+        "size_in_bytes": 7909
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/setopt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8d785b97b1ac87675316f0277ec31f15685d44405a95ee65ac5827ae1c702fad",
+        "sha256_in_prefix": "8d785b97b1ac87675316f0277ec31f15685d44405a95ee65ac5827ae1c702fad",
+        "size_in_bytes": 4725
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/__pycache__/test.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ebaa9aea8b4cb0736d40482ea7fd65353c8fe14490dcb3748a30c7a3629adb5b",
+        "sha256_in_prefix": "ebaa9aea8b4cb0736d40482ea7fd65353c8fe14490dcb3748a30c7a3629adb5b",
+        "size_in_bytes": 1698
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/_requirestxt.py",
+        "path_type": "hardlink",
+        "sha256": "22d60c4c91a1fe2e53950b2d5ff9c5a29a848640b83c915a7412f665ddd5ebbd",
+        "sha256_in_prefix": "22d60c4c91a1fe2e53950b2d5ff9c5a29a848640b83c915a7412f665ddd5ebbd",
+        "size_in_bytes": 4228
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/alias.py",
+        "path_type": "hardlink",
+        "sha256": "ac376b32ddf60d2eaa7f72bbb63659c870ff74c2ab9bbec05dc02dc7e9c14342",
+        "sha256_in_prefix": "ac376b32ddf60d2eaa7f72bbb63659c870ff74c2ab9bbec05dc02dc7e9c14342",
+        "size_in_bytes": 2380
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/bdist_egg.py",
+        "path_type": "hardlink",
+        "sha256": "dde0ee710e1f75e60cb0b3bd3e105f63526470c2e1657827008ffd15d14db041",
+        "sha256_in_prefix": "dde0ee710e1f75e60cb0b3bd3e105f63526470c2e1657827008ffd15d14db041",
+        "size_in_bytes": 16972
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/bdist_rpm.py",
+        "path_type": "hardlink",
+        "sha256": "2f2a88e3dc38f122a4d059ae1ec13d30bcd7d52b978cbed830d6d930566a1482",
+        "sha256_in_prefix": "2f2a88e3dc38f122a4d059ae1ec13d30bcd7d52b978cbed830d6d930566a1482",
+        "size_in_bytes": 1435
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/bdist_wheel.py",
+        "path_type": "hardlink",
+        "sha256": "402b649748922e133917ae6100285afad006c4e771bbd76d24d0612826b8c0b2",
+        "sha256_in_prefix": "402b649748922e133917ae6100285afad006c4e771bbd76d24d0612826b8c0b2",
+        "size_in_bytes": 22274
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/build.py",
+        "path_type": "hardlink",
+        "sha256": "788ed24cc111186644a73935b6f24df29f483a30005cc7062f3963bf69b02373",
+        "sha256_in_prefix": "788ed24cc111186644a73935b6f24df29f483a30005cc7062f3963bf69b02373",
+        "size_in_bytes": 6052
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/build_clib.py",
+        "path_type": "hardlink",
+        "sha256": "01b8293c817fdea2fc7d9af724879b23e5874cc4c188c7eb164550cfc2b8d06e",
+        "sha256_in_prefix": "01b8293c817fdea2fc7d9af724879b23e5874cc4c188c7eb164550cfc2b8d06e",
+        "size_in_bytes": 4528
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/build_ext.py",
+        "path_type": "hardlink",
+        "sha256": "6d41f8334362cda249aefd74c0af990f7b98d13c42499958403862c30cc7b253",
+        "sha256_in_prefix": "6d41f8334362cda249aefd74c0af990f7b98d13c42499958403862c30cc7b253",
+        "size_in_bytes": 18377
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/build_py.py",
+        "path_type": "hardlink",
+        "sha256": "0c26e3bc1d7c9242fec542b9aef9739b40bab704de3b1361caf243c716bb7c82",
+        "sha256_in_prefix": "0c26e3bc1d7c9242fec542b9aef9739b40bab704de3b1361caf243c716bb7c82",
+        "size_in_bytes": 15539
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/develop.py",
+        "path_type": "hardlink",
+        "sha256": "cd7db6d75f6c2351b581f27580d084e21920db36cb2b1d2e530bcd982e5b22ef",
+        "sha256_in_prefix": "cd7db6d75f6c2351b581f27580d084e21920db36cb2b1d2e530bcd982e5b22ef",
+        "size_in_bytes": 6886
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/dist_info.py",
+        "path_type": "hardlink",
+        "sha256": "1d4ef9da22cb9a660c1dbb03060cf6b9b4639202686ee80ea7c1fbd4bcf30f2b",
+        "sha256_in_prefix": "1d4ef9da22cb9a660c1dbb03060cf6b9b4639202686ee80ea7c1fbd4bcf30f2b",
+        "size_in_bytes": 3450
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/easy_install.py",
+        "path_type": "hardlink",
+        "sha256": "d19e2416513bf007b601f1d7613c591546b6b77aa536a5c2b50bb8275371f220",
+        "sha256_in_prefix": "d19e2416513bf007b601f1d7613c591546b6b77aa536a5c2b50bb8275371f220",
+        "size_in_bytes": 87870
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/editable_wheel.py",
+        "path_type": "hardlink",
+        "sha256": "11fa32d549d3f863bb203d417681cd75e1f3364bce5d8adc8804df11f6322dd1",
+        "sha256_in_prefix": "11fa32d549d3f863bb203d417681cd75e1f3364bce5d8adc8804df11f6322dd1",
+        "size_in_bytes": 35626
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/egg_info.py",
+        "path_type": "hardlink",
+        "sha256": "596528cd1dc3642ad6b134211d73b280c88451cae32d6a61113d3e66ca1cb26e",
+        "sha256_in_prefix": "596528cd1dc3642ad6b134211d73b280c88451cae32d6a61113d3e66ca1cb26e",
+        "size_in_bytes": 25982
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/install.py",
+        "path_type": "hardlink",
+        "sha256": "d4f29fa04e05f5f4c31e671c7e50e791bdbcf4221c95d63768fb47c98baeb073",
+        "sha256_in_prefix": "d4f29fa04e05f5f4c31e671c7e50e791bdbcf4221c95d63768fb47c98baeb073",
+        "size_in_bytes": 7045
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/install_egg_info.py",
+        "path_type": "hardlink",
+        "sha256": "dc8f483c21fb0f9f5287ee9a558cfe87ac30cb1abec24c6b2b02a0de70dd26ab",
+        "sha256_in_prefix": "dc8f483c21fb0f9f5287ee9a558cfe87ac30cb1abec24c6b2b02a0de70dd26ab",
+        "size_in_bytes": 2075
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/install_lib.py",
+        "path_type": "hardlink",
+        "sha256": "f67d7f53cdde1dc1112ff6bfaeffcb8470a485794b76ac99e12741a30fbda9c1",
+        "sha256_in_prefix": "f67d7f53cdde1dc1112ff6bfaeffcb8470a485794b76ac99e12741a30fbda9c1",
+        "size_in_bytes": 4319
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/install_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "b553828f77bc39322b9282ff6c66d3e693a4b1dc597d06e51ff6dd2380ed555e",
+        "sha256_in_prefix": "b553828f77bc39322b9282ff6c66d3e693a4b1dc597d06e51ff6dd2380ed555e",
+        "size_in_bytes": 2637
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/launcher manifest.xml",
+        "path_type": "hardlink",
+        "sha256": "c652db8d6ac1d35b4a0b4fa195590e2a48923dbccc9a5d9e38fb49fee7029db1",
+        "sha256_in_prefix": "c652db8d6ac1d35b4a0b4fa195590e2a48923dbccc9a5d9e38fb49fee7029db1",
+        "size_in_bytes": 628
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/rotate.py",
+        "path_type": "hardlink",
+        "sha256": "5cd77f04410e5802475b515c2d3314596978401eb302e93b6fc556420dc51e8b",
+        "sha256_in_prefix": "5cd77f04410e5802475b515c2d3314596978401eb302e93b6fc556420dc51e8b",
+        "size_in_bytes": 2187
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/saveopts.py",
+        "path_type": "hardlink",
+        "sha256": "369d0f55bed20fba136eef59f6ca2c4bb0fe0a4908914ef1e2096ee44b35b630",
+        "sha256_in_prefix": "369d0f55bed20fba136eef59f6ca2c4bb0fe0a4908914ef1e2096ee44b35b630",
+        "size_in_bytes": 692
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/sdist.py",
+        "path_type": "hardlink",
+        "sha256": "25a426dbe79b5c8da4bf2ac18c928ff3234b3dae5e31b31e8acf3c09704c6259",
+        "sha256_in_prefix": "25a426dbe79b5c8da4bf2ac18c928ff3234b3dae5e31b31e8acf3c09704c6259",
+        "size_in_bytes": 7374
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/setopt.py",
+        "path_type": "hardlink",
+        "sha256": "c59176442738001bc4f5e1c7033179d3e7e4420ddabbc7dc45455519de7c9375",
+        "sha256_in_prefix": "c59176442738001bc4f5e1c7033179d3e7e4420ddabbc7dc45455519de7c9375",
+        "size_in_bytes": 5100
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/command/test.py",
+        "path_type": "hardlink",
+        "sha256": "93bc5cabb0fb6c47a18316ab6f0f9d5b702d98664e46acfc1e3291e85189de39",
+        "sha256_in_prefix": "93bc5cabb0fb6c47a18316ab6f0f9d5b702d98664e46acfc1e3291e85189de39",
+        "size_in_bytes": 1343
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "142a4d9d63c8cb46082dddfbda23abda1f81a321bc4323a48a5e85917e661c3e",
+        "sha256_in_prefix": "142a4d9d63c8cb46082dddfbda23abda1f81a321bc4323a48a5e85917e661c3e",
+        "size_in_bytes": 138
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/__pycache__/py310.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "19c4dee5921a00154b575f9a4e1c32e55deccc10f1c4dc0a5975afadaa75d0e1",
+        "sha256_in_prefix": "19c4dee5921a00154b575f9a4e1c32e55deccc10f1c4dc0a5975afadaa75d0e1",
+        "size_in_bytes": 248
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/__pycache__/py311.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "05fe580a20a2b194837cbd154cef1c7728259280b746747281070108f18f6d58",
+        "sha256_in_prefix": "05fe580a20a2b194837cbd154cef1c7728259280b746747281070108f18f6d58",
+        "size_in_bytes": 1092
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/__pycache__/py312.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "241972a91d585b1b8dad7bc7891c8f812822109c01a78ffae3feeb4f34499a7d",
+        "sha256_in_prefix": "241972a91d585b1b8dad7bc7891c8f812822109c01a78ffae3feeb4f34499a7d",
+        "size_in_bytes": 367
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/__pycache__/py39.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "26078f812249e15624c765287d373d8bed04e550c48be577969a5d0a37f31dd2",
+        "sha256_in_prefix": "26078f812249e15624c765287d373d8bed04e550c48be577969a5d0a37f31dd2",
+        "size_in_bytes": 220
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/py310.py",
+        "path_type": "hardlink",
+        "sha256": "f2cab059ccc872b9337806e16a29b8a4a55de2d5d975caa679b81dbf38e2d2b7",
+        "sha256_in_prefix": "f2cab059ccc872b9337806e16a29b8a4a55de2d5d975caa679b81dbf38e2d2b7",
+        "size_in_bytes": 141
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/py311.py",
+        "path_type": "hardlink",
+        "sha256": "7bab49005c1910ff36866301975d0761e4b2a5e968fd38b6c138ca65528bc0e1",
+        "sha256_in_prefix": "7bab49005c1910ff36866301975d0761e4b2a5e968fd38b6c138ca65528bc0e1",
+        "size_in_bytes": 790
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/py312.py",
+        "path_type": "hardlink",
+        "sha256": "bd8295b5dadd393b0efd1f747499045ec1707cc245b881497e5848807ae327e6",
+        "sha256_in_prefix": "bd8295b5dadd393b0efd1f747499045ec1707cc245b881497e5848807ae327e6",
+        "size_in_bytes": 366
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/compat/py39.py",
+        "path_type": "hardlink",
+        "sha256": "04932d9e47dcab24df71caa3610c5fa11b54da74e759a104481564b214e25ea6",
+        "sha256_in_prefix": "04932d9e47dcab24df71caa3610c5fa11b54da74e759a104481564b214e25ea6",
+        "size_in_bytes": 493
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/NOTICE",
+        "path_type": "hardlink",
+        "sha256": "2dddf08818297a3b89d43d95ff659d8da85741108c9136dfa3a4d856c0623bd8",
+        "sha256_in_prefix": "2dddf08818297a3b89d43d95ff659d8da85741108c9136dfa3a4d856c0623bd8",
+        "size_in_bytes": 493
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "6a23e72fd0499f53ba31f9ae357ca7f16d8ba7cbbdaa2cd156ac0f88e74f2236",
+        "sha256_in_prefix": "6a23e72fd0499f53ba31f9ae357ca7f16d8ba7cbbdaa2cd156ac0f88e74f2236",
+        "size_in_bytes": 1499
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "eceebfb32ca3eeaf6b24eefb83f17cc024cb6afabed41759ebc1fad2801dbadc",
+        "sha256_in_prefix": "eceebfb32ca3eeaf6b24eefb83f17cc024cb6afabed41759ebc1fad2801dbadc",
+        "size_in_bytes": 1597
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/__pycache__/_apply_pyprojecttoml.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "36d160078e1162165eab845405235b46ea2e51be6f2bcf58c7d102824f859f23",
+        "sha256_in_prefix": "36d160078e1162165eab845405235b46ea2e51be6f2bcf58c7d102824f859f23",
+        "size_in_bytes": 16398
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/__pycache__/expand.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d7e561c10b81bcbccf1ce28f018b8e66f16a8233441803cca3cc632db787f659",
+        "sha256_in_prefix": "d7e561c10b81bcbccf1ce28f018b8e66f16a8233441803cca3cc632db787f659",
+        "size_in_bytes": 17796
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/__pycache__/pyprojecttoml.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "83ce3d8a66c9576252fc12925188683d6ccd630c8d2d6b64af44adae7e3f9550",
+        "sha256_in_prefix": "83ce3d8a66c9576252fc12925188683d6ccd630c8d2d6b64af44adae7e3f9550",
+        "size_in_bytes": 15671
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/__pycache__/setupcfg.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b70725d30786b062c727fc737248c8e73acedc29f27ac775bd1444663be9ae0c",
+        "sha256_in_prefix": "b70725d30786b062c727fc737248c8e73acedc29f27ac775bd1444663be9ae0c",
+        "size_in_bytes": 23772
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_apply_pyprojecttoml.py",
+        "path_type": "hardlink",
+        "sha256": "3d3798419b484b9091330d8bd65c2737b8e9b4991c090663b18aade27fc7d37a",
+        "sha256_in_prefix": "3d3798419b484b9091330d8bd65c2737b8e9b4991c090663b18aade27fc7d37a",
+        "size_in_bytes": 16988
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/NOTICE",
+        "path_type": "hardlink",
+        "sha256": "09c9bcea95ca086f8bc5bed174e40bc835b297d40fb5f86bbbb570fe0a5581a7",
+        "sha256_in_prefix": "09c9bcea95ca086f8bc5bed174e40bc835b297d40fb5f86bbbb570fe0a5581a7",
+        "size_in_bytes": 18737
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "767a7a4fb78f3f5479cf83ae0bb15dd9d905948aed21f8b351fbe91893fa9f3d",
+        "sha256_in_prefix": "767a7a4fb78f3f5479cf83ae0bb15dd9d905948aed21f8b351fbe91893fa9f3d",
+        "size_in_bytes": 1042
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd553a70dcf590559b6f6cdc61b156b7c35b5230c85deb48804e1aa5828ca806",
+        "sha256_in_prefix": "dd553a70dcf590559b6f6cdc61b156b7c35b5230c85deb48804e1aa5828ca806",
+        "size_in_bytes": 1457
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/error_reporting.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "44e784959010f7f3ca98e426b5d641cd9ce92f46e45df1a79e24913bf5630836",
+        "sha256_in_prefix": "44e784959010f7f3ca98e426b5d641cd9ce92f46e45df1a79e24913bf5630836",
+        "size_in_bytes": 12032
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/extra_validations.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6d8c8a58cf990e27d16ec298f95c1bbb2f21606c68ccfb29915692fd8499a293",
+        "sha256_in_prefix": "6d8c8a58cf990e27d16ec298f95c1bbb2f21606c68ccfb29915692fd8499a293",
+        "size_in_bytes": 1567
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_exceptions.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "557f9d27a6ce113fd303ba9dbeb4913b7e34854a9ddd13bc32c6d72543c7cf55",
+        "sha256_in_prefix": "557f9d27a6ce113fd303ba9dbeb4913b7e34854a9ddd13bc32c6d72543c7cf55",
+        "size_in_bytes": 2415
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f70e27a99d2c648016538775e1994e3f3108b77370ae458a664fe3628ea79081",
+        "sha256_in_prefix": "f70e27a99d2c648016538775e1994e3f3108b77370ae458a664fe3628ea79081",
+        "size_in_bytes": 83803
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/__pycache__/formats.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8abef8d5ab9ef3600e251f9adfb3f3b169e8b936ca9754a6f48520bae6f75bc4",
+        "sha256_in_prefix": "8abef8d5ab9ef3600e251f9adfb3f3b169e8b936ca9754a6f48520bae6f75bc4",
+        "size_in_bytes": 12605
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/error_reporting.py",
+        "path_type": "hardlink",
+        "sha256": "99e95d0fb9c141da25421bc6fb8debd547be814d67ece440251f3abe1dd1aef9",
+        "sha256_in_prefix": "99e95d0fb9c141da25421bc6fb8debd547be814d67ece440251f3abe1dd1aef9",
+        "size_in_bytes": 11813
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/extra_validations.py",
+        "path_type": "hardlink",
+        "sha256": "91dd12598aeca7721717d28600cf10a5e68aa46c8cb0d80bfad8e1f533df8726",
+        "sha256_in_prefix": "91dd12598aeca7721717d28600cf10a5e68aa46c8cb0d80bfad8e1f533df8726",
+        "size_in_bytes": 1625
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py",
+        "path_type": "hardlink",
+        "sha256": "c3be3d260a8a8bc72504570e6dd71b655aac985e2827f401ca16754866d414dc",
+        "sha256_in_prefix": "c3be3d260a8a8bc72504570e6dd71b655aac985e2827f401ca16754866d414dc",
+        "size_in_bytes": 1612
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_validations.py",
+        "path_type": "hardlink",
+        "sha256": "4fc46f2528b9dd805f0c1e2644fb85ea0b0fc71f3ebbc2985f9eb2deaa24a7fe",
+        "sha256_in_prefix": "4fc46f2528b9dd805f0c1e2644fb85ea0b0fc71f3ebbc2985f9eb2deaa24a7fe",
+        "size_in_bytes": 335460
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/_validate_pyproject/formats.py",
+        "path_type": "hardlink",
+        "sha256": "323cfa463c7504c0f0d974cc01f4beb0ce71e45bf9697d9993fab933feeb7ff7",
+        "sha256_in_prefix": "323cfa463c7504c0f0d974cc01f4beb0ce71e45bf9697d9993fab933feeb7ff7",
+        "size_in_bytes": 12814
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/distutils.schema.json",
+        "path_type": "hardlink",
+        "sha256": "4dca77da44678703911b0ffda7a1848b4f258f6875e6d411cce6016f31a67015",
+        "sha256_in_prefix": "4dca77da44678703911b0ffda7a1848b4f258f6875e6d411cce6016f31a67015",
+        "size_in_bytes": 972
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/expand.py",
+        "path_type": "hardlink",
+        "sha256": "24d024b510accb2441fab42875b3e70ae7262d6a9c62fcc20c2f046e7d99ef13",
+        "sha256_in_prefix": "24d024b510accb2441fab42875b3e70ae7262d6a9c62fcc20c2f046e7d99ef13",
+        "size_in_bytes": 16041
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/pyprojecttoml.py",
+        "path_type": "hardlink",
+        "sha256": "60cbb93dd6c9248e5ace9ea447f6e833599f95fe67a8e03e227178b3a2e72e0c",
+        "sha256_in_prefix": "60cbb93dd6c9248e5ace9ea447f6e833599f95fe67a8e03e227178b3a2e72e0c",
+        "size_in_bytes": 18320
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/setupcfg.py",
+        "path_type": "hardlink",
+        "sha256": "5590e4c04ec362fe3949b69d243f02c0aac3b625ef8e09652fc3d84afa110b28",
+        "sha256_in_prefix": "5590e4c04ec362fe3949b69d243f02c0aac3b625ef8e09652fc3d84afa110b28",
+        "size_in_bytes": 26575
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/config/setuptools.schema.json",
+        "path_type": "hardlink",
+        "sha256": "759051b921276646ada1596dd645701bca1c4de45d3bb043d31bce58a1f9e0f6",
+        "sha256_in_prefix": "759051b921276646ada1596dd645701bca1c4de45d3bb043d31bce58a1f9e0f6",
+        "size_in_bytes": 16071
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/depends.py",
+        "path_type": "hardlink",
+        "sha256": "8ca61f8e6b7fd9941856085bf0bf5b53b2c9e9eac7279cdef8afdf295d413179",
+        "sha256_in_prefix": "8ca61f8e6b7fd9941856085bf0bf5b53b2c9e9eac7279cdef8afdf295d413179",
+        "size_in_bytes": 5965
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/discovery.py",
+        "path_type": "hardlink",
+        "sha256": "fb8d9cdd7870ce47e874328a3f9d02d98073af5d5f9dc020994cc174145bd3e4",
+        "sha256_in_prefix": "fb8d9cdd7870ce47e874328a3f9d02d98073af5d5f9dc020994cc174145bd3e4",
+        "size_in_bytes": 21258
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/dist.py",
+        "path_type": "hardlink",
+        "sha256": "f61cdee6922879848f14eaaf873d218adb9ac443ec578c0df6c63785c7f785f8",
+        "sha256_in_prefix": "f61cdee6922879848f14eaaf873d218adb9ac443ec578c0df6c63785c7f785f8",
+        "size_in_bytes": 38815
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/errors.py",
+        "path_type": "hardlink",
+        "sha256": "818db1d8f21a220cb4d724403510becdc0b0c430aa09272026808e6457b4ca2a",
+        "sha256_in_prefix": "818db1d8f21a220cb4d724403510becdc0b0c430aa09272026808e6457b4ca2a",
+        "size_in_bytes": 3024
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/extension.py",
+        "path_type": "hardlink",
+        "sha256": "2829eff69ded826d1956ab60138e757f220bb26e210b2bce894b4ebbbf3b0fee",
+        "sha256_in_prefix": "2829eff69ded826d1956ab60138e757f220bb26e210b2bce894b4ebbbf3b0fee",
+        "size_in_bytes": 6683
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/glob.py",
+        "path_type": "hardlink",
+        "sha256": "002fc1df70d8f20f821c42f10ec26bb7016ba62b9c48066c6a43c5752390ce17",
+        "sha256_in_prefix": "002fc1df70d8f20f821c42f10ec26bb7016ba62b9c48066c6a43c5752390ce17",
+        "size_in_bytes": 6062
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/gui-32.exe",
+        "path_type": "hardlink",
+        "sha256": "85dae1e95d77845f2cb59bcac3d4afe74bbe4c91a9bcc5bf4a71cd43104dbe7c",
+        "sha256_in_prefix": "85dae1e95d77845f2cb59bcac3d4afe74bbe4c91a9bcc5bf4a71cd43104dbe7c",
+        "size_in_bytes": 11776
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/gui-64.exe",
+        "path_type": "hardlink",
+        "sha256": "3471b6140eadc6412277dbbefe3fef8c345a0f1a59776086b80a3618c3a83e3b",
+        "sha256_in_prefix": "3471b6140eadc6412277dbbefe3fef8c345a0f1a59776086b80a3618c3a83e3b",
+        "size_in_bytes": 14336
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/gui-arm64.exe",
+        "path_type": "hardlink",
+        "sha256": "e694f4743405c8b5926ff457db6fe7f1a12dec7c16a9c3864784d3f4e07ae097",
+        "sha256_in_prefix": "e694f4743405c8b5926ff457db6fe7f1a12dec7c16a9c3864784d3f4e07ae097",
+        "size_in_bytes": 13824
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/gui.exe",
+        "path_type": "hardlink",
+        "sha256": "85dae1e95d77845f2cb59bcac3d4afe74bbe4c91a9bcc5bf4a71cd43104dbe7c",
+        "sha256_in_prefix": "85dae1e95d77845f2cb59bcac3d4afe74bbe4c91a9bcc5bf4a71cd43104dbe7c",
+        "size_in_bytes": 11776
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/installer.py",
+        "path_type": "hardlink",
+        "sha256": "ff859e831e2bdcbd39b0ca37f8896a169f8ebb19d6c81aa3c8c67b2d64179a1f",
+        "sha256_in_prefix": "ff859e831e2bdcbd39b0ca37f8896a169f8ebb19d6c81aa3c8c67b2d64179a1f",
+        "size_in_bytes": 5110
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/launch.py",
+        "path_type": "hardlink",
+        "sha256": "2016f9944bfaf42cae67d7b022b98a957875e7891d2e63f6f4b29f4cc9318a61",
+        "sha256_in_prefix": "2016f9944bfaf42cae67d7b022b98a957875e7891d2e63f6f4b29f4cc9318a61",
+        "size_in_bytes": 820
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/logging.py",
+        "path_type": "hardlink",
+        "sha256": "5b5ea21c9d477025d8434471cab11f27cdc54f8d7be6d0ada1883e13ab92a552",
+        "sha256_in_prefix": "5b5ea21c9d477025d8434471cab11f27cdc54f8d7be6d0ada1883e13ab92a552",
+        "size_in_bytes": 1261
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/modified.py",
+        "path_type": "hardlink",
+        "sha256": "6706df05f0853fcf25b6f6effdd243cfeb752ec4239ccf895298199e74198e33",
+        "sha256_in_prefix": "6706df05f0853fcf25b6f6effdd243cfeb752ec4239ccf895298199e74198e33",
+        "size_in_bytes": 568
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/monkey.py",
+        "path_type": "hardlink",
+        "sha256": "1703169769f5bf66c76dea81cbea3d83cc9435a0246056eccc26d77bd77965af",
+        "sha256_in_prefix": "1703169769f5bf66c76dea81cbea3d83cc9435a0246056eccc26d77bd77965af",
+        "size_in_bytes": 3717
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/msvc.py",
+        "path_type": "hardlink",
+        "sha256": "b7777f1d9ea032acaa9e1cf974f441b8ccb04d33e4dcbca5216933b744425673",
+        "sha256_in_prefix": "b7777f1d9ea032acaa9e1cf974f441b8ccb04d33e4dcbca5216933b744425673",
+        "size_in_bytes": 41255
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/namespaces.py",
+        "path_type": "hardlink",
+        "sha256": "d861aa618d4134312132d05cd6b1d3bfb92582635545d92c25e5be2f57fefb2b",
+        "sha256_in_prefix": "d861aa618d4134312132d05cd6b1d3bfb92582635545d92c25e5be2f57fefb2b",
+        "size_in_bytes": 3171
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/package_index.py",
+        "path_type": "hardlink",
+        "sha256": "5c125b84d2017bb097808f73ce17b12826890cf5a28253bd9e81c4dbf8b0a689",
+        "sha256_in_prefix": "5c125b84d2017bb097808f73ce17b12826890cf5a28253bd9e81c4dbf8b0a689",
+        "size_in_bytes": 39315
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/sandbox.py",
+        "path_type": "hardlink",
+        "sha256": "7ccaad70eba2a473ba44a3e1d58079a3b77df3974b2a8efa5a1a77beb21e8b61",
+        "sha256_in_prefix": "7ccaad70eba2a473ba44a3e1d58079a3b77df3974b2a8efa5a1a77beb21e8b61",
+        "size_in_bytes": 14906
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/script (dev).tmpl",
+        "path_type": "hardlink",
+        "sha256": "454cd0cc2414697b7074bb581d661b21098e6844b906baaad45bd403fb6efb92",
+        "sha256_in_prefix": "454cd0cc2414697b7074bb581d661b21098e6844b906baaad45bd403fb6efb92",
+        "size_in_bytes": 218
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/script.tmpl",
+        "path_type": "hardlink",
+        "sha256": "5864ede6989eccedbb73e0dbc7a9794384f715fdb4039cfbf3bda1bf76808586",
+        "sha256_in_prefix": "5864ede6989eccedbb73e0dbc7a9794384f715fdb4039cfbf3bda1bf76808586",
+        "size_in_bytes": 138
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "02705f96cda225b4c343398c29e2d1b7ef65c6168e1d454e644817bfcf54c2fb",
+        "sha256_in_prefix": "02705f96cda225b4c343398c29e2d1b7ef65c6168e1d454e644817bfcf54c2fb",
+        "size_in_bytes": 335
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "46732646bf69228265c655c173148554aefaeb9780a7d606bbbf9b3baf1b8a0c",
+        "sha256_in_prefix": "46732646bf69228265c655c173148554aefaeb9780a7d606bbbf9b3baf1b8a0c",
+        "size_in_bytes": 444
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/contexts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "160272010d7906830f61392e051fe2c6219ca60258c0f96340e408fd9a5a639b",
+        "sha256_in_prefix": "160272010d7906830f61392e051fe2c6219ca60258c0f96340e408fd9a5a639b",
+        "size_in_bytes": 3871
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/environment.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0d5390f785bf5c00ca7292f424a8acf2abcdf48471612061433f62b4d34335ba",
+        "sha256_in_prefix": "0d5390f785bf5c00ca7292f424a8acf2abcdf48471612061433f62b4d34335ba",
+        "size_in_bytes": 2077
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/fixtures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "20ab32bc521d629ffe1536cd12e3d53b7b2733b20aa674a3369e3b7d06da7c23",
+        "sha256_in_prefix": "20ab32bc521d629ffe1536cd12e3d53b7b2733b20aa674a3369e3b7d06da7c23",
+        "size_in_bytes": 4059
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/mod_with_constant.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0a7270f074f99293f35a3d79d4ba49f79b4c7125480fa4a6cacb93f600ab3161",
+        "sha256_in_prefix": "0a7270f074f99293f35a3d79d4ba49f79b4c7125480fa4a6cacb93f600ab3161",
+        "size_in_bytes": 167
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/namespaces.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8946bc0ecf2ac076f0a65f9b447ff979e8da68da7f73c6ae4fdaac92a63887e4",
+        "sha256_in_prefix": "8946bc0ecf2ac076f0a65f9b447ff979e8da68da7f73c6ae4fdaac92a63887e4",
+        "size_in_bytes": 2701
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/script-with-bom.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dc3340d6339f4e4f6a5afebf7e70cc536ea4366ea89a29abaf1251243f43576e",
+        "sha256_in_prefix": "dc3340d6339f4e4f6a5afebf7e70cc536ea4366ea89a29abaf1251243f43576e",
+        "size_in_bytes": 161
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/server.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5a5a2752eeb96e7fdc55485acf2f9eff70ab9adc1ca64385767d656891471aef",
+        "sha256_in_prefix": "5a5a2752eeb96e7fdc55485acf2f9eff70ab9adc1ca64385767d656891471aef",
+        "size_in_bytes": 3359
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_archive_util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "204c8dbe22e88e22a530b2cfdded6db55b56beb40e34fac3767843e2d9be529d",
+        "sha256_in_prefix": "204c8dbe22e88e22a530b2cfdded6db55b56beb40e34fac3767843e2d9be529d",
+        "size_in_bytes": 1121
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_bdist_deprecations.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1b218a8759285615e019234c0f09664f1ccaf7fd2371b6f1ba3a7f9d5d51792f",
+        "sha256_in_prefix": "1b218a8759285615e019234c0f09664f1ccaf7fd2371b6f1ba3a7f9d5d51792f",
+        "size_in_bytes": 1010
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_bdist_egg.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "54473de99330549034bcb0f531d4899c5f55ce2889b8eeb83772562695bb1fcf",
+        "sha256_in_prefix": "54473de99330549034bcb0f531d4899c5f55ce2889b8eeb83772562695bb1fcf",
+        "size_in_bytes": 2322
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_bdist_wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bb189b8bbcba21e373564fcbf2381d33aafef2ce67cf70f3ef323b57b9c6fdda",
+        "sha256_in_prefix": "bb189b8bbcba21e373564fcbf2381d33aafef2ce67cf70f3ef323b57b9c6fdda",
+        "size_in_bytes": 20468
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_build.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b17fcabb34563ff5b66792d6dbab6edda199dc7c91102dc4df377ab931732dbf",
+        "sha256_in_prefix": "b17fcabb34563ff5b66792d6dbab6edda199dc7c91102dc4df377ab931732dbf",
+        "size_in_bytes": 1377
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_build_clib.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "444e86fd4100d5fa18c5c16fa6bbdedacd436e3bfecf38b53cd9d5418e547dcd",
+        "sha256_in_prefix": "444e86fd4100d5fa18c5c16fa6bbdedacd436e3bfecf38b53cd9d5418e547dcd",
+        "size_in_bytes": 2236
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_build_ext.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d5d5f6b3bf0aa7c4c8194d25f81f8184afa75c9ce3b1c2799cbff3553a06c668",
+        "sha256_in_prefix": "d5d5f6b3bf0aa7c4c8194d25f81f8184afa75c9ce3b1c2799cbff3553a06c668",
+        "size_in_bytes": 9365
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_build_meta.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "db41c8d4933658ba4cd197a0107d02deb62e3a1cc66c9b3838878cfe09449d97",
+        "sha256_in_prefix": "db41c8d4933658ba4cd197a0107d02deb62e3a1cc66c9b3838878cfe09449d97",
+        "size_in_bytes": 28855
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_build_py.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e7dff25e937c9383fe32fc056857e5df475d4b1180ebed9b96f45be97002964b",
+        "sha256_in_prefix": "e7dff25e937c9383fe32fc056857e5df475d4b1180ebed9b96f45be97002964b",
+        "size_in_bytes": 10816
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_config_discovery.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8f68289adb4cfe219530232ec8483acfb336bfb894a12b6d486e40204571daf1",
+        "sha256_in_prefix": "8f68289adb4cfe219530232ec8483acfb336bfb894a12b6d486e40204571daf1",
+        "size_in_bytes": 20452
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_core_metadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4709fba4652d9a00a897adfeae6c91518df158c8ae8e7cb0557bd1f699d4600f",
+        "sha256_in_prefix": "4709fba4652d9a00a897adfeae6c91518df158c8ae8e7cb0557bd1f699d4600f",
+        "size_in_bytes": 14757
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_depends.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "407b3a8b928b09742b61951c0e9d0ae865de4112196e7de0d3ef68d029c360bc",
+        "sha256_in_prefix": "407b3a8b928b09742b61951c0e9d0ae865de4112196e7de0d3ef68d029c360bc",
+        "size_in_bytes": 744
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_develop.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6837c12bb4e15b42dc32b4d57024fb960f493631e540a7d85c43f9674d0d59ef",
+        "sha256_in_prefix": "6837c12bb4e15b42dc32b4d57024fb960f493631e540a7d85c43f9674d0d59ef",
+        "size_in_bytes": 5601
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_dist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "513e1f9eec61f824ffa207577e2c5de665ddb48a84f35263796a88ca33e99120",
+        "sha256_in_prefix": "513e1f9eec61f824ffa207577e2c5de665ddb48a84f35263796a88ca33e99120",
+        "size_in_bytes": 6881
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_dist_info.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "3166f0544ad04af113c262b882741d1e9ee5570a472ab40386dd05f0c6490da3",
+        "sha256_in_prefix": "3166f0544ad04af113c262b882741d1e9ee5570a472ab40386dd05f0c6490da3",
+        "size_in_bytes": 6996
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_distutils_adoption.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bc4ac96d8ee9984e50e0e7a4f118215d2fb6bf3d63665f3d5313af62187904af",
+        "sha256_in_prefix": "bc4ac96d8ee9984e50e0e7a4f118215d2fb6bf3d63665f3d5313af62187904af",
+        "size_in_bytes": 5598
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_easy_install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bdce35f392206d9640e4fad93a0e8f15b18e979d0d02fd497847867da00b9cee",
+        "sha256_in_prefix": "bdce35f392206d9640e4fad93a0e8f15b18e979d0d02fd497847867da00b9cee",
+        "size_in_bytes": 44380
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_editable_install.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1dabcd6b8a9cbbd04d3be9ad727f43f642fee437f44a4fc9295a74e6a69b99af",
+        "sha256_in_prefix": "1dabcd6b8a9cbbd04d3be9ad727f43f642fee437f44a4fc9295a74e6a69b99af",
+        "size_in_bytes": 36636
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_egg_info.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "f61b5a05402384d99df3f924576cb21248a40bd24f006f2304671219a248ad1c",
+        "sha256_in_prefix": "f61b5a05402384d99df3f924576cb21248a40bd24f006f2304671219a248ad1c",
+        "size_in_bytes": 30823
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_extern.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ce60866029b6b50a9500ce0dc6a01cc40bf876cf2c13fb3b6ea740c73a853520",
+        "sha256_in_prefix": "ce60866029b6b50a9500ce0dc6a01cc40bf876cf2c13fb3b6ea740c73a853520",
+        "size_in_bytes": 592
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_find_packages.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "108c15c6f1ad058e400def4d18931a154dd9dba6f63d3133c7bb74779fe4e8ff",
+        "sha256_in_prefix": "108c15c6f1ad058e400def4d18931a154dd9dba6f63d3133c7bb74779fe4e8ff",
+        "size_in_bytes": 8119
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_find_py_modules.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "18f30aa24a9cc52a993faf4e84556c3e408a5a214fb2e4039e33e9761d352dad",
+        "sha256_in_prefix": "18f30aa24a9cc52a993faf4e84556c3e408a5a214fb2e4039e33e9761d352dad",
+        "size_in_bytes": 2657
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_glob.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d258f7819548971d24c280f7ac48708fae0152630ee8b0a891fdec8292301944",
+        "sha256_in_prefix": "d258f7819548971d24c280f7ac48708fae0152630ee8b0a891fdec8292301944",
+        "size_in_bytes": 949
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_install_scripts.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "abd00f0bff46f95914ffd625b8d8cfae35803fd00210f6e40b11cf2f51afdc8a",
+        "sha256_in_prefix": "abd00f0bff46f95914ffd625b8d8cfae35803fd00210f6e40b11cf2f51afdc8a",
+        "size_in_bytes": 3797
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_logging.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "600c86880802454274ebca73c8138680150d95ba24f590622c0aec6076166a10",
+        "sha256_in_prefix": "600c86880802454274ebca73c8138680150d95ba24f590622c0aec6076166a10",
+        "size_in_bytes": 2025
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_manifest.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5249edac9f275b85859930dd98696c1e3a9731b5b3149c27f2cf89f18ce798c3",
+        "sha256_in_prefix": "5249edac9f275b85859930dd98696c1e3a9731b5b3149c27f2cf89f18ce798c3",
+        "size_in_bytes": 16026
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_namespaces.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4ab699385eb3334f2591a8d5d83dbdaf3a330765eb36fa36ff45a62330cb3ad3",
+        "sha256_in_prefix": "4ab699385eb3334f2591a8d5d83dbdaf3a330765eb36fa36ff45a62330cb3ad3",
+        "size_in_bytes": 3445
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_packageindex.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2729aaf2efcf765f6e1599b8c5702092b6ac9ae280c80fd083d186aa1cf02a86",
+        "sha256_in_prefix": "2729aaf2efcf765f6e1599b8c5702092b6ac9ae280c80fd083d186aa1cf02a86",
+        "size_in_bytes": 13923
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_sandbox.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ecf578c412ed2d5480ce21986f67e2857f30fdea8dba981f084552d249277b3b",
+        "sha256_in_prefix": "ecf578c412ed2d5480ce21986f67e2857f30fdea8dba981f084552d249277b3b",
+        "size_in_bytes": 6258
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_sdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "af8aa711ae7aaf671dd2ed3ba527c4808c8830a3483dd63a23b827ce151ff317",
+        "sha256_in_prefix": "af8aa711ae7aaf671dd2ed3ba527c4808c8830a3483dd63a23b827ce151ff317",
+        "size_in_bytes": 28110
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_setopt.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "8b55934c9dfa1962cbc58ab32b2a6c3579b5a9d194f8916746349cb8897802da",
+        "sha256_in_prefix": "8b55934c9dfa1962cbc58ab32b2a6c3579b5a9d194f8916746349cb8897802da",
+        "size_in_bytes": 1871
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_setuptools.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "572127a3c3864eefe7456fc7a413944f60afe3f0cff2af3a77d55d0be78b3f12",
+        "sha256_in_prefix": "572127a3c3864eefe7456fc7a413944f60afe3f0cff2af3a77d55d0be78b3f12",
+        "size_in_bytes": 9999
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_shutil_wrapper.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "381c9657093455fbdb58773e287916f37db4f0ad95c9950c6c87472ea6986ebb",
+        "sha256_in_prefix": "381c9657093455fbdb58773e287916f37db4f0ad95c9950c6c87472ea6986ebb",
+        "size_in_bytes": 817
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_unicode_utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0cb1173b352eac8fd48db3b7767de9db93454e89e5e5be16bb4217c269fa0e8a",
+        "sha256_in_prefix": "0cb1173b352eac8fd48db3b7767de9db93454e89e5e5be16bb4217c269fa0e8a",
+        "size_in_bytes": 671
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_virtualenv.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "912ab23ffb50e8e8c31e397d4a1486489c08bab82a8e1d1beeee4327dee4ac65",
+        "sha256_in_prefix": "912ab23ffb50e8e8c31e397d4a1486489c08bab82a8e1d1beeee4327dee4ac65",
+        "size_in_bytes": 2749
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_warnings.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "c7fc4c5be30357e6daa2e55cc8ad7cea2f0efd1baa8427610827f50be64c80eb",
+        "sha256_in_prefix": "c7fc4c5be30357e6daa2e55cc8ad7cea2f0efd1baa8427610827f50be64c80eb",
+        "size_in_bytes": 3176
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b62db571a922ece7b51671e7fe1b09dcc59a14ce3f390570b21f3893ea250f55",
+        "sha256_in_prefix": "b62db571a922ece7b51671e7fe1b09dcc59a14ce3f390570b21f3893ea250f55",
+        "size_in_bytes": 13075
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/test_windows_wrappers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "296f09c8e3db0202d1ae91caf20a4ed339519ab4952b993a8f113cc7199dbca2",
+        "sha256_in_prefix": "296f09c8e3db0202d1ae91caf20a4ed339519ab4952b993a8f113cc7199dbca2",
+        "size_in_bytes": 7366
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/text.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fc85266fea56e087a79a240cc0e6a7592c5c236f00b18be3a8dca94ab5597e27",
+        "sha256_in_prefix": "fc85266fea56e087a79a240cc0e6a7592c5c236f00b18be3a8dca94ab5597e27",
+        "size_in_bytes": 379
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/__pycache__/textwrap.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "7e37c3a21a2c9197a509767b4d14ffbb7cd039434090673a372cf019b7a72059",
+        "sha256_in_prefix": "7e37c3a21a2c9197a509767b4d14ffbb7cd039434090673a372cf019b7a72059",
+        "size_in_bytes": 306
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/compat/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/compat/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5f173750e37a01e7f9eab05e9333c18d119a170af57cb5b6ebcc24afcf29e6b6",
+        "sha256_in_prefix": "5f173750e37a01e7f9eab05e9333c18d119a170af57cb5b6ebcc24afcf29e6b6",
+        "size_in_bytes": 144
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/compat/__pycache__/py39.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "16015d2f19adf0be6d09535e7715ba2cfe18d572d3b59d4a48c4fb95b49e7131",
+        "sha256_in_prefix": "16015d2f19adf0be6d09535e7715ba2cfe18d572d3b59d4a48c4fb95b49e7131",
+        "size_in_bytes": 269
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/compat/py39.py",
+        "path_type": "hardlink",
+        "sha256": "794cbbfc5fba2914ce20a97ebdeb2152ee88d0475349d059321d04574959d7e8",
+        "sha256_in_prefix": "794cbbfc5fba2914ce20a97ebdeb2152ee88d0475349d059321d04574959d7e8",
+        "size_in_bytes": 135
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d8fc63da628269f3287ee5330d3cec4f60c7f0ee5009fb046aa5ee5ee6e29a52",
+        "sha256_in_prefix": "d8fc63da628269f3287ee5330d3cec4f60c7f0ee5009fb046aa5ee5ee6e29a52",
+        "size_in_bytes": 144
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/__pycache__/test_apply_pyprojecttoml.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "1dbe016d5dacf6480aeba47df0245fe34309350012aa6c57d1b19f242847df81",
+        "sha256_in_prefix": "1dbe016d5dacf6480aeba47df0245fe34309350012aa6c57d1b19f242847df81",
+        "size_in_bytes": 19446
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/__pycache__/test_expand.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "707a3864b1bc29f427e75d13281d6fd0516f5bfacb85e987bab2b7093128a60e",
+        "sha256_in_prefix": "707a3864b1bc29f427e75d13281d6fd0516f5bfacb85e987bab2b7093128a60e",
+        "size_in_bytes": 7780
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "193ba341a66faa51b559bf6c3d7cb89bdbec3b191f58474eda706ac80fbd6180",
+        "sha256_in_prefix": "193ba341a66faa51b559bf6c3d7cb89bdbec3b191f58474eda706ac80fbd6180",
+        "size_in_bytes": 11036
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/__pycache__/test_pyprojecttoml_dynamic_deps.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "23c60eafd5af37d7dd727b5486ea65d53d5c3406d2afccdc5d5847f080bbf53c",
+        "sha256_in_prefix": "23c60eafd5af37d7dd727b5486ea65d53d5c3406d2afccdc5d5847f080bbf53c",
+        "size_in_bytes": 3350
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/__pycache__/test_setupcfg.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "5cf36673f97ec3c38084eb868a0ba51cac12529dac745c2f637fa68e4c0e379c",
+        "sha256_in_prefix": "5cf36673f97ec3c38084eb868a0ba51cac12529dac745c2f637fa68e4c0e379c",
+        "size_in_bytes": 28188
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/downloads/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "f62c670c47722ff6ab29b5337ee8897ed023f5b1b12b3f0cf5a94e159323c7d6",
+        "sha256_in_prefix": "f62c670c47722ff6ab29b5337ee8897ed023f5b1b12b3f0cf5a94e159323c7d6",
+        "size_in_bytes": 1827
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/downloads/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d7dfeaa33f4483d7908f9cde28bc9424d708afcb70536af41bd7f1183f4d0a65",
+        "sha256_in_prefix": "d7dfeaa33f4483d7908f9cde28bc9424d708afcb70536af41bd7f1183f4d0a65",
+        "size_in_bytes": 2065
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/downloads/__pycache__/preload.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "affc3a686d860386632efb76a10046fb6c5a4dd56ddaa83a6f7bc61a2bb4a603",
+        "sha256_in_prefix": "affc3a686d860386632efb76a10046fb6c5a4dd56ddaa83a6f7bc61a2bb4a603",
+        "size_in_bytes": 631
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/downloads/preload.py",
+        "path_type": "hardlink",
+        "sha256": "b081866696377263293308896186181c6da27d9264bc9804a2d445b62ba55752",
+        "sha256_in_prefix": "b081866696377263293308896186181c6da27d9264bc9804a2d445b62ba55752",
+        "size_in_bytes": 450
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/setupcfg_examples.txt",
+        "path_type": "hardlink",
+        "sha256": "7006d5bc26e4159b9350beb1451cd182ac81d2b2ef2537efc370f7d20968d8e1",
+        "sha256_in_prefix": "7006d5bc26e4159b9350beb1451cd182ac81d2b2ef2537efc370f7d20968d8e1",
+        "size_in_bytes": 1912
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/test_apply_pyprojecttoml.py",
+        "path_type": "hardlink",
+        "sha256": "5637e79abdbfec666609c063f2afab53df60836786ac93dba898eafdd4add6e5",
+        "sha256_in_prefix": "5637e79abdbfec666609c063f2afab53df60836786ac93dba898eafdd4add6e5",
+        "size_in_bytes": 20286
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/test_expand.py",
+        "path_type": "hardlink",
+        "sha256": "4b4a13e89be003fa2e8d1e184b8454b9fe6098eb75093415eba4500f357cc5de",
+        "sha256_in_prefix": "4b4a13e89be003fa2e8d1e184b8454b9fe6098eb75093415eba4500f357cc5de",
+        "size_in_bytes": 8933
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/test_pyprojecttoml.py",
+        "path_type": "hardlink",
+        "sha256": "d0b79f4a58d4840e8caad279015ccb8689aa65c62214a76eff57240de313d4b6",
+        "sha256_in_prefix": "d0b79f4a58d4840e8caad279015ccb8689aa65c62214a76eff57240de313d4b6",
+        "size_in_bytes": 12406
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py",
+        "path_type": "hardlink",
+        "sha256": "f56ef7fb22e16499af0a23b8ad3890a01a594f9c0d03dd176dde67d870ac85de",
+        "sha256_in_prefix": "f56ef7fb22e16499af0a23b8ad3890a01a594f9c0d03dd176dde67d870ac85de",
+        "size_in_bytes": 3271
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/config/test_setupcfg.py",
+        "path_type": "hardlink",
+        "sha256": "af965027a9adea6c9b6f175fbfcbba3e5e0ae4fb453623545b1728862c33f00c",
+        "sha256_in_prefix": "af965027a9adea6c9b6f175fbfcbba3e5e0ae4fb453623545b1728862c33f00c",
+        "size_in_bytes": 33189
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/contexts.py",
+        "path_type": "hardlink",
+        "sha256": "4c07592b19a6a1dc75131315a34d68e10a518e9229a385f72162aafc19e3c695",
+        "sha256_in_prefix": "4c07592b19a6a1dc75131315a34d68e10a518e9229a385f72162aafc19e3c695",
+        "size_in_bytes": 3480
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/environment.py",
+        "path_type": "hardlink",
+        "sha256": "f79fd4b536918aebf0602f5e5ca1076e7d36903b59cacbd9ab75192663d48f52",
+        "sha256_in_prefix": "f79fd4b536918aebf0602f5e5ca1076e7d36903b59cacbd9ab75192663d48f52",
+        "size_in_bytes": 3102
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/fixtures.py",
+        "path_type": "hardlink",
+        "sha256": "f95ee20fa05e136134470e9d56f4ce0a6dfa246f194d39eb5e13741884a582b8",
+        "sha256_in_prefix": "f95ee20fa05e136134470e9d56f4ce0a6dfa246f194d39eb5e13741884a582b8",
+        "size_in_bytes": 5197
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/indexes/test_links_priority/external.html",
+        "path_type": "hardlink",
+        "sha256": "78bf5eb8eb84f7724a65daa55f104e9476cac08b8db8876aec6051a6c68f31c5",
+        "sha256_in_prefix": "78bf5eb8eb84f7724a65daa55f104e9476cac08b8db8876aec6051a6c68f31c5",
+        "size_in_bytes": 92
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/indexes/test_links_priority/simple/foobar/index.html",
+        "path_type": "hardlink",
+        "sha256": "0c3f932abed4538cc08c71f3e157b1603352033476ee57af4a1d5cfa4dd974b1",
+        "sha256_in_prefix": "0c3f932abed4538cc08c71f3e157b1603352033476ee57af4a1d5cfa4dd974b1",
+        "size_in_bytes": 174
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/integration/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/integration/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fd59bfb7441c10a39e8ddfc0f24b342a94dc85e5658d262b7aa1a2be85869cdb",
+        "sha256_in_prefix": "fd59bfb7441c10a39e8ddfc0f24b342a94dc85e5658d262b7aa1a2be85869cdb",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/integration/__pycache__/helpers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6aec366d49d9e8ddd9544cefa8bcd30c5333c627fd1cfd4f58b7d8157eda54ac",
+        "sha256_in_prefix": "6aec366d49d9e8ddd9544cefa8bcd30c5333c627fd1cfd4f58b7d8157eda54ac",
+        "size_in_bytes": 3155
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/integration/__pycache__/test_pip_install_sdist.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "bbc568c52cda378d2e7f2b6adb805eec309117866c8b1773f3d5c1e988a3c36e",
+        "sha256_in_prefix": "bbc568c52cda378d2e7f2b6adb805eec309117866c8b1773f3d5c1e988a3c36e",
+        "size_in_bytes": 6049
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/integration/helpers.py",
+        "path_type": "hardlink",
+        "sha256": "dcf1dc4bd48203e7f05499943f669de4d40eb6d240113239367a1cff1ae83b99",
+        "sha256_in_prefix": "dcf1dc4bd48203e7f05499943f669de4d40eb6d240113239367a1cff1ae83b99",
+        "size_in_bytes": 2522
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/integration/test_pip_install_sdist.py",
+        "path_type": "hardlink",
+        "sha256": "b995b4dded78d69fbe035e8eb78600ba0052de1eb20211253da4324d22409f32",
+        "sha256_in_prefix": "b995b4dded78d69fbe035e8eb78600ba0052de1eb20211253da4324d22409f32",
+        "size_in_bytes": 8204
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/mod_with_constant.py",
+        "path_type": "hardlink",
+        "sha256": "5ff2a3f34339e70d6d990e1feee658f7565300ba3884a553e841f1818a1c50c4",
+        "sha256_in_prefix": "5ff2a3f34339e70d6d990e1feee658f7565300ba3884a553e841f1818a1c50c4",
+        "size_in_bytes": 22
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/namespaces.py",
+        "path_type": "hardlink",
+        "sha256": "1cf708de74793021565e96800c82757f02b1ca671080192ec3cec87393d44804",
+        "sha256_in_prefix": "1cf708de74793021565e96800c82757f02b1ca671080192ec3cec87393d44804",
+        "size_in_bytes": 2774
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/script-with-bom.py",
+        "path_type": "hardlink",
+        "sha256": "851460222cc450b1a21bf653368318e3a1e12a1c6959fcb9146703e906e1e5f7",
+        "sha256_in_prefix": "851460222cc450b1a21bf653368318e3a1e12a1c6959fcb9146703e906e1e5f7",
+        "size_in_bytes": 18
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/server.py",
+        "path_type": "hardlink",
+        "sha256": "d050d97f471222708fe67d6168aec0c47a378c3dbad512bb0f7f918cff85e779",
+        "sha256_in_prefix": "d050d97f471222708fe67d6168aec0c47a378c3dbad512bb0f7f918cff85e779",
+        "size_in_bytes": 2397
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_archive_util.py",
+        "path_type": "hardlink",
+        "sha256": "6eeb8a758f17916dba3dedc8280a014461c6d0c0ee9a7b8da0f8365ac010cc88",
+        "sha256_in_prefix": "6eeb8a758f17916dba3dedc8280a014461c6d0c0ee9a7b8da0f8365ac010cc88",
+        "size_in_bytes": 845
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_bdist_deprecations.py",
+        "path_type": "hardlink",
+        "sha256": "ef95eade0627efd2c8232bac125b5b1da9f46c4800b767bf09a2fb28b4bcf8a4",
+        "sha256_in_prefix": "ef95eade0627efd2c8232bac125b5b1da9f46c4800b767bf09a2fb28b4bcf8a4",
+        "size_in_bytes": 775
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_bdist_egg.py",
+        "path_type": "hardlink",
+        "sha256": "e8f6983751772436c8875b8ad2eaefef2245731f7ccf9767f52389f0cbfdd65f",
+        "sha256_in_prefix": "e8f6983751772436c8875b8ad2eaefef2245731f7ccf9767f52389f0cbfdd65f",
+        "size_in_bytes": 1957
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_bdist_wheel.py",
+        "path_type": "hardlink",
+        "sha256": "0b73e9ee9d9f5021afb87d0876af25082d80061b2ee06da237925aa1cc8d1d0c",
+        "sha256_in_prefix": "0b73e9ee9d9f5021afb87d0876af25082d80061b2ee06da237925aa1cc8d1d0c",
+        "size_in_bytes": 19906
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_build.py",
+        "path_type": "hardlink",
+        "sha256": "c0980ccf68701c00dc2c583e9d7af045586eb3b8639807841a0ae9210c021a70",
+        "sha256_in_prefix": "c0980ccf68701c00dc2c583e9d7af045586eb3b8639807841a0ae9210c021a70",
+        "size_in_bytes": 798
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_build_clib.py",
+        "path_type": "hardlink",
+        "sha256": "6d7e755d101fe2e3bb22e1c5a6378f9e82bc984ef837682ca1e12a17ea1f830b",
+        "sha256_in_prefix": "6d7e755d101fe2e3bb22e1c5a6378f9e82bc984ef837682ca1e12a17ea1f830b",
+        "size_in_bytes": 3123
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_build_ext.py",
+        "path_type": "hardlink",
+        "sha256": "7b8652c6c60f079cead4a4aa184b804d9d2dd0f250ccc8638e4289fa12237207",
+        "sha256_in_prefix": "7b8652c6c60f079cead4a4aa184b804d9d2dd0f250ccc8638e4289fa12237207",
+        "size_in_bytes": 10099
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_build_meta.py",
+        "path_type": "hardlink",
+        "sha256": "891a0639fe6f7a196d4e575b82173dee91e3fbc9c3c9afcd97df81b1dca5f10d",
+        "sha256_in_prefix": "891a0639fe6f7a196d4e575b82173dee91e3fbc9c3c9afcd97df81b1dca5f10d",
+        "size_in_bytes": 33574
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_build_py.py",
+        "path_type": "hardlink",
+        "sha256": "fb50e71042606af4053f3a0b80773e42b885bf496568ea75604afb2c35c2481a",
+        "sha256_in_prefix": "fb50e71042606af4053f3a0b80773e42b885bf496568ea75604afb2c35c2481a",
+        "size_in_bytes": 14187
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_config_discovery.py",
+        "path_type": "hardlink",
+        "sha256": "16a57e94eb64a9a23e6b2cd4db3a1c49d0f94da4408026678b13438a5280e854",
+        "sha256_in_prefix": "16a57e94eb64a9a23e6b2cd4db3a1c49d0f94da4408026678b13438a5280e854",
+        "size_in_bytes": 22580
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_core_metadata.py",
+        "path_type": "hardlink",
+        "sha256": "1699cf8ecb919c0fbc8d10ef05eda823fdef8afc233533ee1760acc0238d5c0e",
+        "sha256_in_prefix": "1699cf8ecb919c0fbc8d10ef05eda823fdef8afc233533ee1760acc0238d5c0e",
+        "size_in_bytes": 19102
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_depends.py",
+        "path_type": "hardlink",
+        "sha256": "c90057a106cd425262b7a99b455a33e816f9e777f7b0daead369598a6373e576",
+        "sha256_in_prefix": "c90057a106cd425262b7a99b455a33e816f9e777f7b0daead369598a6373e576",
+        "size_in_bytes": 424
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_develop.py",
+        "path_type": "hardlink",
+        "sha256": "08bcd767cf9be7e5454ee6aee0fe325c474bc7551dc9315c39fad5d2ac9421d1",
+        "sha256_in_prefix": "08bcd767cf9be7e5454ee6aee0fe325c474bc7551dc9315c39fad5d2ac9421d1",
+        "size_in_bytes": 5142
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_dist.py",
+        "path_type": "hardlink",
+        "sha256": "1db4d9a7b0f93732c08776edad4f0b7ae66fe127c00036bd115b9b799caede21",
+        "sha256_in_prefix": "1db4d9a7b0f93732c08776edad4f0b7ae66fe127c00036bd115b9b799caede21",
+        "size_in_bytes": 8897
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_dist_info.py",
+        "path_type": "hardlink",
+        "sha256": "020cb72f4337845e5dc57c12a4b27021b809237383cbf6ec1f6ddc1144763a53",
+        "sha256_in_prefix": "020cb72f4337845e5dc57c12a4b27021b809237383cbf6ec1f6ddc1144763a53",
+        "size_in_bytes": 7094
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_distutils_adoption.py",
+        "path_type": "hardlink",
+        "sha256": "fdeca7ace7f212a5c51268d4261ce97bc1973f24d43ef35239bb38a80026072f",
+        "sha256_in_prefix": "fdeca7ace7f212a5c51268d4261ce97bc1973f24d43ef35239bb38a80026072f",
+        "size_in_bytes": 5987
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_easy_install.py",
+        "path_type": "hardlink",
+        "sha256": "0fc86c93e67485872b2a8c8a33c027291d087557e05c3951db20114a85c3cd37",
+        "sha256_in_prefix": "0fc86c93e67485872b2a8c8a33c027291d087557e05c3951db20114a85c3cd37",
+        "size_in_bytes": 53308
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_editable_install.py",
+        "path_type": "hardlink",
+        "sha256": "ede4c4b694f493b41e572660eb87a1de4667f928dc92e07d2dca243ae577ec32",
+        "sha256_in_prefix": "ede4c4b694f493b41e572660eb87a1de4667f928dc92e07d2dca243ae577ec32",
+        "size_in_bytes": 43383
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_egg_info.py",
+        "path_type": "hardlink",
+        "sha256": "d018b6f489be3f3fd2bcab4a564abbb32dad60476bbdfbc23b27b17d3c778f2a",
+        "sha256_in_prefix": "d018b6f489be3f3fd2bcab4a564abbb32dad60476bbdfbc23b27b17d3c778f2a",
+        "size_in_bytes": 43963
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_extern.py",
+        "path_type": "hardlink",
+        "sha256": "ae9294ea809c92cba62f07f94de2a50e5b854344d47db3f04cb41ba71705ac25",
+        "sha256_in_prefix": "ae9294ea809c92cba62f07f94de2a50e5b854344d47db3f04cb41ba71705ac25",
+        "size_in_bytes": 296
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_find_packages.py",
+        "path_type": "hardlink",
+        "sha256": "0932c0713cd619604b09c776680b14564bcede26eb96a7b114174328e58fa2af",
+        "sha256_in_prefix": "0932c0713cd619604b09c776680b14564bcede26eb96a7b114174328e58fa2af",
+        "size_in_bytes": 7819
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_find_py_modules.py",
+        "path_type": "hardlink",
+        "sha256": "cd08ee8481b94d03764893e2c7d011a380cbff0f382e7f10b070d48e36ebb404",
+        "sha256_in_prefix": "cd08ee8481b94d03764893e2c7d011a380cbff0f382e7f10b070d48e36ebb404",
+        "size_in_bytes": 2404
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_glob.py",
+        "path_type": "hardlink",
+        "sha256": "3f726fa47fa45d0e01677cef445fb32b13a0c325b3c08690233d161ddc52d249",
+        "sha256_in_prefix": "3f726fa47fa45d0e01677cef445fb32b13a0c325b3c08690233d161ddc52d249",
+        "size_in_bytes": 887
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_install_scripts.py",
+        "path_type": "hardlink",
+        "sha256": "b1c22b27a6bfb2c2aa838bc804d6948e600a1c460b51467d58a9cf78a9c4ea07",
+        "sha256_in_prefix": "b1c22b27a6bfb2c2aa838bc804d6948e600a1c460b51467d58a9cf78a9c4ea07",
+        "size_in_bytes": 3433
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_logging.py",
+        "path_type": "hardlink",
+        "sha256": "ce51390e595dba40bb25ce7814dbc357feeec7712b024adfacde424ac9cd3944",
+        "sha256_in_prefix": "ce51390e595dba40bb25ce7814dbc357feeec7712b024adfacde424ac9cd3944",
+        "size_in_bytes": 2099
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_manifest.py",
+        "path_type": "hardlink",
+        "sha256": "78c83ae69200e760e2cc1ea6a64b5253e6fc0a3c1a3424b931280bfd5d4bac52",
+        "sha256_in_prefix": "78c83ae69200e760e2cc1ea6a64b5253e6fc0a3c1a3424b931280bfd5d4bac52",
+        "size_in_bytes": 18562
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_namespaces.py",
+        "path_type": "hardlink",
+        "sha256": "63abada1ee4f1c7a8bfc39606b0a81f45f17a6c5033efbf0d6c40c7a72b4e1ed",
+        "sha256_in_prefix": "63abada1ee4f1c7a8bfc39606b0a81f45f17a6c5033efbf0d6c40c7a72b4e1ed",
+        "size_in_bytes": 4515
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_packageindex.py",
+        "path_type": "hardlink",
+        "sha256": "a848cb1e94aeda00247a0c04b2dcc7413f8e9b5b902188c0f3378dcc45fbf6ea",
+        "sha256_in_prefix": "a848cb1e94aeda00247a0c04b2dcc7413f8e9b5b902188c0f3378dcc45fbf6ea",
+        "size_in_bytes": 8775
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_sandbox.py",
+        "path_type": "hardlink",
+        "sha256": "b2151613b7cb4d67bb27375f8ba36178159ab86de852e91b515e3a700ac3d2ed",
+        "sha256_in_prefix": "b2151613b7cb4d67bb27375f8ba36178159ab86de852e91b515e3a700ac3d2ed",
+        "size_in_bytes": 4330
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_sdist.py",
+        "path_type": "hardlink",
+        "sha256": "d1221f95729fde0d2134f63c6596eac7fcd5e122b5a28e97e80f39dec80a621e",
+        "sha256_in_prefix": "d1221f95729fde0d2134f63c6596eac7fcd5e122b5a28e97e80f39dec80a621e",
+        "size_in_bytes": 32428
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_setopt.py",
+        "path_type": "hardlink",
+        "sha256": "dd5c713380137cff8fe001a70e3a160a71ebe7e8bd0921104c5614d7e1539ef2",
+        "sha256_in_prefix": "dd5c713380137cff8fe001a70e3a160a71ebe7e8bd0921104c5614d7e1539ef2",
+        "size_in_bytes": 1365
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_setuptools.py",
+        "path_type": "hardlink",
+        "sha256": "fde221a8a7f8e7e3ad1eac517f6d0a9dd39926525d4b43ee14b5c13b733e2cdf",
+        "sha256_in_prefix": "fde221a8a7f8e7e3ad1eac517f6d0a9dd39926525d4b43ee14b5c13b733e2cdf",
+        "size_in_bytes": 9008
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_shutil_wrapper.py",
+        "path_type": "hardlink",
+        "sha256": "835e44d753ed6711be227076056345c87facbce6d7c765dc32180c2c93ee1677",
+        "sha256_in_prefix": "835e44d753ed6711be227076056345c87facbce6d7c765dc32180c2c93ee1677",
+        "size_in_bytes": 641
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_unicode_utils.py",
+        "path_type": "hardlink",
+        "sha256": "c567c4125f239100adf68b615135c97c599dc804c0160809b36b53c636ee99bc",
+        "sha256_in_prefix": "c567c4125f239100adf68b615135c97c599dc804c0160809b36b53c636ee99bc",
+        "size_in_bytes": 316
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_virtualenv.py",
+        "path_type": "hardlink",
+        "sha256": "83e9e30bff494c0b35615c7fd5d189fd0e919489cee2a295bbdf9702035be936",
+        "sha256_in_prefix": "83e9e30bff494c0b35615c7fd5d189fd0e919489cee2a295bbdf9702035be936",
+        "size_in_bytes": 3730
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_warnings.py",
+        "path_type": "hardlink",
+        "sha256": "cf0476cdc9c2782783a882d994938f01cbb23c7a03bc6bb53ad3956222cc93be",
+        "sha256_in_prefix": "cf0476cdc9c2782783a882d994938f01cbb23c7a03bc6bb53ad3956222cc93be",
+        "size_in_bytes": 3347
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_wheel.py",
+        "path_type": "hardlink",
+        "sha256": "27ef375b529d5d38008c5644dc7fb2b68861bc31358aa75b139605e632d09464",
+        "sha256_in_prefix": "27ef375b529d5d38008c5644dc7fb2b68861bc31358aa75b139605e632d09464",
+        "size_in_bytes": 19370
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/test_windows_wrappers.py",
+        "path_type": "hardlink",
+        "sha256": "685e944e8c0ddf2cc281d061f670d056f6087d262882b4caefbe931325c406a8",
+        "sha256_in_prefix": "685e944e8c0ddf2cc281d061f670d056f6087d262882b4caefbe931325c406a8",
+        "size_in_bytes": 7881
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/text.py",
+        "path_type": "hardlink",
+        "sha256": "6b5db5f7ba4c553bc1e85016434ba34fc7c84222c8589945025d5409a0d40df8",
+        "sha256_in_prefix": "6b5db5f7ba4c553bc1e85016434ba34fc7c84222c8589945025d5409a0d40df8",
+        "size_in_bytes": 123
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/tests/textwrap.py",
+        "path_type": "hardlink",
+        "sha256": "14d34dabf322684271f3c3e7b1b250211c668f5aa681c00e0975d1b0e0cf24de",
+        "sha256_in_prefix": "14d34dabf322684271f3c3e7b1b250211c668f5aa681c00e0975d1b0e0cf24de",
+        "size_in_bytes": 98
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/unicode_utils.py",
+        "path_type": "hardlink",
+        "sha256": "77d33dc66c4a408258c0d6456b820fa481442936f120069ed63368571bb5d80c",
+        "sha256_in_prefix": "77d33dc66c4a408258c0d6456b820fa481442936f120069ed63368571bb5d80c",
+        "size_in_bytes": 3190
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/version.py",
+        "path_type": "hardlink",
+        "sha256": "58909e52ecaaef80289364de2bdf8e7b164ebbc5eb950cbbfb2d0112e58da2f4",
+        "sha256_in_prefix": "58909e52ecaaef80289364de2bdf8e7b164ebbc5eb950cbbfb2d0112e58da2f4",
+        "size_in_bytes": 161
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/warnings.py",
+        "path_type": "hardlink",
+        "sha256": "a18d127b978eaa37bf144ca34e0a2751cd171b082cac8e5c826d64930ba5cffc",
+        "sha256_in_prefix": "a18d127b978eaa37bf144ca34e0a2751cd171b082cac8e5c826d64930ba5cffc",
+        "size_in_bytes": 3796
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/wheel.py",
+        "path_type": "hardlink",
+        "sha256": "c6402dbe09bbb8f4f2615db3a95990d3003c90bc0ec914f625eb35cc0cb4ecab",
+        "sha256_in_prefix": "c6402dbe09bbb8f4f2615db3a95990d3003c90bc0ec914f625eb35cc0cb4ecab",
+        "size_in_bytes": 8624
+      },
+      {
+        "_path": "Lib/site-packages/setuptools/windows_support.py",
+        "path_type": "hardlink",
+        "sha256": "c16e0860b33506fed9d4c69ab8fdb198f8f2cbec249909d7772bd7b1c01ff5fc",
+        "sha256_in_prefix": "c16e0860b33506fed9d4c69ab8fdb198f8f2cbec249909d7772bd7b1c01ff5fc",
+        "size_in_bytes": 726
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "d9dbf6c4b1294fefa75e3e7da825840fc66ea7eff5050cdcf1a4936a921ba840",
+  "size": 1762706,
+  "subdir": "win-64",
+  "timestamp": 1738046475691,
+  "track_features": "",
+  "url": "https://repo.anaconda.com/pkgs/main/win-64/setuptools-75.8.0-py39haa95532_0.conda",
+  "version": "75.8.0"
+}
\ No newline at end of file
diff --git a/marketing/conda-meta/sqlite-3.45.3-h2bbff1b_0.json b/marketing/conda-meta/sqlite-3.45.3-h2bbff1b_0.json
new file mode 100644
index 0000000000000000000000000000000000000000..a1f49170394bb110f8dab2595a9a2a47969f979d
--- /dev/null
+++ b/marketing/conda-meta/sqlite-3.45.3-h2bbff1b_0.json
@@ -0,0 +1,79 @@
+{
+  "build": "h2bbff1b_0",
+  "build_number": 0,
+  "channel": "https://repo.anaconda.com/pkgs/main/win-64",
+  "constrains": [],
+  "depends": [
+    "vc >=14.1,<15.0a0",
+    "vs2015_runtime >=14.16.27012,<15.0a0"
+  ],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\sqlite-3.45.3-h2bbff1b_0",
+  "features": "",
+  "files": [
+    "Library/bin/sqlite3.dll",
+    "Library/bin/sqlite3.exe",
+    "Library/include/sqlite3.h",
+    "Library/include/sqlite3ext.h",
+    "Library/lib/sqlite3.lib",
+    ".nonadmin"
+  ],
+  "fn": "sqlite-3.45.3-h2bbff1b_0.conda",
+  "legacy_bz2_md5": "833b93a2daade3407898f15588945d83",
+  "license": "blessing",
+  "license_family": "Other",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\sqlite-3.45.3-h2bbff1b_0",
+    "type": 1
+  },
+  "md5": "c5b3b929349655302bf811c45571da6d",
+  "name": "sqlite",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\sqlite-3.45.3-h2bbff1b_0.conda",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "Library/bin/sqlite3.dll",
+        "path_type": "hardlink",
+        "sha256": "0ca33a3cdbd4f54084e64e8ca71ae986f6d738a20d38400470011cd794ec9c02",
+        "sha256_in_prefix": "0ca33a3cdbd4f54084e64e8ca71ae986f6d738a20d38400470011cd794ec9c02",
+        "size_in_bytes": 1596176
+      },
+      {
+        "_path": "Library/bin/sqlite3.exe",
+        "path_type": "hardlink",
+        "sha256": "8d2751bcf5a96e7cb16decf9f1d3f75eb2414e437fc379a9c9a6630276a79456",
+        "sha256_in_prefix": "8d2751bcf5a96e7cb16decf9f1d3f75eb2414e437fc379a9c9a6630276a79456",
+        "size_in_bytes": 2009368
+      },
+      {
+        "_path": "Library/include/sqlite3.h",
+        "path_type": "hardlink",
+        "sha256": "abc0ac2188c3500fd5744352fbfaf4e9c485b94946a5656ad3be53fdefe2f0db",
+        "sha256_in_prefix": "abc0ac2188c3500fd5744352fbfaf4e9c485b94946a5656ad3be53fdefe2f0db",
+        "size_in_bytes": 642024
+      },
+      {
+        "_path": "Library/include/sqlite3ext.h",
+        "path_type": "hardlink",
+        "sha256": "b184dd1586d935133d37ad76fa353faf0a1021ff2fdedeedcc3498fff74bbb94",
+        "sha256_in_prefix": "b184dd1586d935133d37ad76fa353faf0a1021ff2fdedeedcc3498fff74bbb94",
+        "size_in_bytes": 38149
+      },
+      {
+        "_path": "Library/lib/sqlite3.lib",
+        "path_type": "hardlink",
+        "sha256": "27cc212c61743e898801f77237552371aafc81a69ac83103bf84895f119a1a96",
+        "sha256_in_prefix": "27cc212c61743e898801f77237552371aafc81a69ac83103bf84895f119a1a96",
+        "size_in_bytes": 67692
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "bb25d778d309491d947d3758ec79652aa637c1808041114b1bd45e8bdd7bd776",
+  "size": 996331,
+  "subdir": "win-64",
+  "timestamp": 1714488344682,
+  "track_features": "",
+  "url": "https://repo.anaconda.com/pkgs/main/win-64/sqlite-3.45.3-h2bbff1b_0.conda",
+  "version": "3.45.3"
+}
\ No newline at end of file
diff --git a/marketing/conda-meta/tzdata-2025a-h04d1e81_0.json b/marketing/conda-meta/tzdata-2025a-h04d1e81_0.json
new file mode 100644
index 0000000000000000000000000000000000000000..5288745a29020fd55decea26a28323d16f1aa67d
--- /dev/null
+++ b/marketing/conda-meta/tzdata-2025a-h04d1e81_0.json
@@ -0,0 +1,4878 @@
+{
+  "build": "h04d1e81_0",
+  "build_number": 0,
+  "channel": "https://repo.anaconda.com/pkgs/main/noarch",
+  "constrains": [],
+  "depends": [],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\tzdata-2025a-h04d1e81_0",
+  "features": "",
+  "files": [
+    "share/zoneinfo/Africa/Abidjan",
+    "share/zoneinfo/Africa/Accra",
+    "share/zoneinfo/Africa/Addis_Ababa",
+    "share/zoneinfo/Africa/Algiers",
+    "share/zoneinfo/Africa/Asmara",
+    "share/zoneinfo/Africa/Asmera",
+    "share/zoneinfo/Africa/Bamako",
+    "share/zoneinfo/Africa/Bangui",
+    "share/zoneinfo/Africa/Banjul",
+    "share/zoneinfo/Africa/Bissau",
+    "share/zoneinfo/Africa/Blantyre",
+    "share/zoneinfo/Africa/Brazzaville",
+    "share/zoneinfo/Africa/Bujumbura",
+    "share/zoneinfo/Africa/Cairo",
+    "share/zoneinfo/Africa/Casablanca",
+    "share/zoneinfo/Africa/Ceuta",
+    "share/zoneinfo/Africa/Conakry",
+    "share/zoneinfo/Africa/Dakar",
+    "share/zoneinfo/Africa/Dar_es_Salaam",
+    "share/zoneinfo/Africa/Djibouti",
+    "share/zoneinfo/Africa/Douala",
+    "share/zoneinfo/Africa/El_Aaiun",
+    "share/zoneinfo/Africa/Freetown",
+    "share/zoneinfo/Africa/Gaborone",
+    "share/zoneinfo/Africa/Harare",
+    "share/zoneinfo/Africa/Johannesburg",
+    "share/zoneinfo/Africa/Juba",
+    "share/zoneinfo/Africa/Kampala",
+    "share/zoneinfo/Africa/Khartoum",
+    "share/zoneinfo/Africa/Kigali",
+    "share/zoneinfo/Africa/Kinshasa",
+    "share/zoneinfo/Africa/Lagos",
+    "share/zoneinfo/Africa/Libreville",
+    "share/zoneinfo/Africa/Lome",
+    "share/zoneinfo/Africa/Luanda",
+    "share/zoneinfo/Africa/Lubumbashi",
+    "share/zoneinfo/Africa/Lusaka",
+    "share/zoneinfo/Africa/Malabo",
+    "share/zoneinfo/Africa/Maputo",
+    "share/zoneinfo/Africa/Maseru",
+    "share/zoneinfo/Africa/Mbabane",
+    "share/zoneinfo/Africa/Mogadishu",
+    "share/zoneinfo/Africa/Monrovia",
+    "share/zoneinfo/Africa/Nairobi",
+    "share/zoneinfo/Africa/Ndjamena",
+    "share/zoneinfo/Africa/Niamey",
+    "share/zoneinfo/Africa/Nouakchott",
+    "share/zoneinfo/Africa/Ouagadougou",
+    "share/zoneinfo/Africa/Porto-Novo",
+    "share/zoneinfo/Africa/Sao_Tome",
+    "share/zoneinfo/Africa/Timbuktu",
+    "share/zoneinfo/Africa/Tripoli",
+    "share/zoneinfo/Africa/Tunis",
+    "share/zoneinfo/Africa/Windhoek",
+    "share/zoneinfo/America/Adak",
+    "share/zoneinfo/America/Anchorage",
+    "share/zoneinfo/America/Anguilla",
+    "share/zoneinfo/America/Antigua",
+    "share/zoneinfo/America/Araguaina",
+    "share/zoneinfo/America/Argentina/Buenos_Aires",
+    "share/zoneinfo/America/Argentina/Catamarca",
+    "share/zoneinfo/America/Argentina/ComodRivadavia",
+    "share/zoneinfo/America/Argentina/Cordoba",
+    "share/zoneinfo/America/Argentina/Jujuy",
+    "share/zoneinfo/America/Argentina/La_Rioja",
+    "share/zoneinfo/America/Argentina/Mendoza",
+    "share/zoneinfo/America/Argentina/Rio_Gallegos",
+    "share/zoneinfo/America/Argentina/Salta",
+    "share/zoneinfo/America/Argentina/San_Juan",
+    "share/zoneinfo/America/Argentina/San_Luis",
+    "share/zoneinfo/America/Argentina/Tucuman",
+    "share/zoneinfo/America/Argentina/Ushuaia",
+    "share/zoneinfo/America/Aruba",
+    "share/zoneinfo/America/Asuncion",
+    "share/zoneinfo/America/Atikokan",
+    "share/zoneinfo/America/Atka",
+    "share/zoneinfo/America/Bahia",
+    "share/zoneinfo/America/Bahia_Banderas",
+    "share/zoneinfo/America/Barbados",
+    "share/zoneinfo/America/Belem",
+    "share/zoneinfo/America/Belize",
+    "share/zoneinfo/America/Blanc-Sablon",
+    "share/zoneinfo/America/Boa_Vista",
+    "share/zoneinfo/America/Bogota",
+    "share/zoneinfo/America/Boise",
+    "share/zoneinfo/America/Buenos_Aires",
+    "share/zoneinfo/America/Cambridge_Bay",
+    "share/zoneinfo/America/Campo_Grande",
+    "share/zoneinfo/America/Cancun",
+    "share/zoneinfo/America/Caracas",
+    "share/zoneinfo/America/Catamarca",
+    "share/zoneinfo/America/Cayenne",
+    "share/zoneinfo/America/Cayman",
+    "share/zoneinfo/America/Chicago",
+    "share/zoneinfo/America/Chihuahua",
+    "share/zoneinfo/America/Ciudad_Juarez",
+    "share/zoneinfo/America/Coral_Harbour",
+    "share/zoneinfo/America/Cordoba",
+    "share/zoneinfo/America/Costa_Rica",
+    "share/zoneinfo/America/Creston",
+    "share/zoneinfo/America/Cuiaba",
+    "share/zoneinfo/America/Curacao",
+    "share/zoneinfo/America/Danmarkshavn",
+    "share/zoneinfo/America/Dawson",
+    "share/zoneinfo/America/Dawson_Creek",
+    "share/zoneinfo/America/Denver",
+    "share/zoneinfo/America/Detroit",
+    "share/zoneinfo/America/Dominica",
+    "share/zoneinfo/America/Edmonton",
+    "share/zoneinfo/America/Eirunepe",
+    "share/zoneinfo/America/El_Salvador",
+    "share/zoneinfo/America/Ensenada",
+    "share/zoneinfo/America/Fort_Nelson",
+    "share/zoneinfo/America/Fort_Wayne",
+    "share/zoneinfo/America/Fortaleza",
+    "share/zoneinfo/America/Glace_Bay",
+    "share/zoneinfo/America/Godthab",
+    "share/zoneinfo/America/Goose_Bay",
+    "share/zoneinfo/America/Grand_Turk",
+    "share/zoneinfo/America/Grenada",
+    "share/zoneinfo/America/Guadeloupe",
+    "share/zoneinfo/America/Guatemala",
+    "share/zoneinfo/America/Guayaquil",
+    "share/zoneinfo/America/Guyana",
+    "share/zoneinfo/America/Halifax",
+    "share/zoneinfo/America/Havana",
+    "share/zoneinfo/America/Hermosillo",
+    "share/zoneinfo/America/Indiana/Indianapolis",
+    "share/zoneinfo/America/Indiana/Knox",
+    "share/zoneinfo/America/Indiana/Marengo",
+    "share/zoneinfo/America/Indiana/Petersburg",
+    "share/zoneinfo/America/Indiana/Tell_City",
+    "share/zoneinfo/America/Indiana/Vevay",
+    "share/zoneinfo/America/Indiana/Vincennes",
+    "share/zoneinfo/America/Indiana/Winamac",
+    "share/zoneinfo/America/Indianapolis",
+    "share/zoneinfo/America/Inuvik",
+    "share/zoneinfo/America/Iqaluit",
+    "share/zoneinfo/America/Jamaica",
+    "share/zoneinfo/America/Jujuy",
+    "share/zoneinfo/America/Juneau",
+    "share/zoneinfo/America/Kentucky/Louisville",
+    "share/zoneinfo/America/Kentucky/Monticello",
+    "share/zoneinfo/America/Knox_IN",
+    "share/zoneinfo/America/Kralendijk",
+    "share/zoneinfo/America/La_Paz",
+    "share/zoneinfo/America/Lima",
+    "share/zoneinfo/America/Los_Angeles",
+    "share/zoneinfo/America/Louisville",
+    "share/zoneinfo/America/Lower_Princes",
+    "share/zoneinfo/America/Maceio",
+    "share/zoneinfo/America/Managua",
+    "share/zoneinfo/America/Manaus",
+    "share/zoneinfo/America/Marigot",
+    "share/zoneinfo/America/Martinique",
+    "share/zoneinfo/America/Matamoros",
+    "share/zoneinfo/America/Mazatlan",
+    "share/zoneinfo/America/Mendoza",
+    "share/zoneinfo/America/Menominee",
+    "share/zoneinfo/America/Merida",
+    "share/zoneinfo/America/Metlakatla",
+    "share/zoneinfo/America/Mexico_City",
+    "share/zoneinfo/America/Miquelon",
+    "share/zoneinfo/America/Moncton",
+    "share/zoneinfo/America/Monterrey",
+    "share/zoneinfo/America/Montevideo",
+    "share/zoneinfo/America/Montreal",
+    "share/zoneinfo/America/Montserrat",
+    "share/zoneinfo/America/Nassau",
+    "share/zoneinfo/America/New_York",
+    "share/zoneinfo/America/Nipigon",
+    "share/zoneinfo/America/Nome",
+    "share/zoneinfo/America/Noronha",
+    "share/zoneinfo/America/North_Dakota/Beulah",
+    "share/zoneinfo/America/North_Dakota/Center",
+    "share/zoneinfo/America/North_Dakota/New_Salem",
+    "share/zoneinfo/America/Nuuk",
+    "share/zoneinfo/America/Ojinaga",
+    "share/zoneinfo/America/Panama",
+    "share/zoneinfo/America/Pangnirtung",
+    "share/zoneinfo/America/Paramaribo",
+    "share/zoneinfo/America/Phoenix",
+    "share/zoneinfo/America/Port-au-Prince",
+    "share/zoneinfo/America/Port_of_Spain",
+    "share/zoneinfo/America/Porto_Acre",
+    "share/zoneinfo/America/Porto_Velho",
+    "share/zoneinfo/America/Puerto_Rico",
+    "share/zoneinfo/America/Punta_Arenas",
+    "share/zoneinfo/America/Rainy_River",
+    "share/zoneinfo/America/Rankin_Inlet",
+    "share/zoneinfo/America/Recife",
+    "share/zoneinfo/America/Regina",
+    "share/zoneinfo/America/Resolute",
+    "share/zoneinfo/America/Rio_Branco",
+    "share/zoneinfo/America/Rosario",
+    "share/zoneinfo/America/Santa_Isabel",
+    "share/zoneinfo/America/Santarem",
+    "share/zoneinfo/America/Santiago",
+    "share/zoneinfo/America/Santo_Domingo",
+    "share/zoneinfo/America/Sao_Paulo",
+    "share/zoneinfo/America/Scoresbysund",
+    "share/zoneinfo/America/Shiprock",
+    "share/zoneinfo/America/Sitka",
+    "share/zoneinfo/America/St_Barthelemy",
+    "share/zoneinfo/America/St_Johns",
+    "share/zoneinfo/America/St_Kitts",
+    "share/zoneinfo/America/St_Lucia",
+    "share/zoneinfo/America/St_Thomas",
+    "share/zoneinfo/America/St_Vincent",
+    "share/zoneinfo/America/Swift_Current",
+    "share/zoneinfo/America/Tegucigalpa",
+    "share/zoneinfo/America/Thule",
+    "share/zoneinfo/America/Thunder_Bay",
+    "share/zoneinfo/America/Tijuana",
+    "share/zoneinfo/America/Toronto",
+    "share/zoneinfo/America/Tortola",
+    "share/zoneinfo/America/Vancouver",
+    "share/zoneinfo/America/Virgin",
+    "share/zoneinfo/America/Whitehorse",
+    "share/zoneinfo/America/Winnipeg",
+    "share/zoneinfo/America/Yakutat",
+    "share/zoneinfo/America/Yellowknife",
+    "share/zoneinfo/Antarctica/Casey",
+    "share/zoneinfo/Antarctica/Davis",
+    "share/zoneinfo/Antarctica/DumontDUrville",
+    "share/zoneinfo/Antarctica/Macquarie",
+    "share/zoneinfo/Antarctica/Mawson",
+    "share/zoneinfo/Antarctica/McMurdo",
+    "share/zoneinfo/Antarctica/Palmer",
+    "share/zoneinfo/Antarctica/Rothera",
+    "share/zoneinfo/Antarctica/South_Pole",
+    "share/zoneinfo/Antarctica/Syowa",
+    "share/zoneinfo/Antarctica/Troll",
+    "share/zoneinfo/Antarctica/Vostok",
+    "share/zoneinfo/Arctic/Longyearbyen",
+    "share/zoneinfo/Asia/Aden",
+    "share/zoneinfo/Asia/Almaty",
+    "share/zoneinfo/Asia/Amman",
+    "share/zoneinfo/Asia/Anadyr",
+    "share/zoneinfo/Asia/Aqtau",
+    "share/zoneinfo/Asia/Aqtobe",
+    "share/zoneinfo/Asia/Ashgabat",
+    "share/zoneinfo/Asia/Ashkhabad",
+    "share/zoneinfo/Asia/Atyrau",
+    "share/zoneinfo/Asia/Baghdad",
+    "share/zoneinfo/Asia/Bahrain",
+    "share/zoneinfo/Asia/Baku",
+    "share/zoneinfo/Asia/Bangkok",
+    "share/zoneinfo/Asia/Barnaul",
+    "share/zoneinfo/Asia/Beirut",
+    "share/zoneinfo/Asia/Bishkek",
+    "share/zoneinfo/Asia/Brunei",
+    "share/zoneinfo/Asia/Calcutta",
+    "share/zoneinfo/Asia/Chita",
+    "share/zoneinfo/Asia/Choibalsan",
+    "share/zoneinfo/Asia/Chongqing",
+    "share/zoneinfo/Asia/Chungking",
+    "share/zoneinfo/Asia/Colombo",
+    "share/zoneinfo/Asia/Dacca",
+    "share/zoneinfo/Asia/Damascus",
+    "share/zoneinfo/Asia/Dhaka",
+    "share/zoneinfo/Asia/Dili",
+    "share/zoneinfo/Asia/Dubai",
+    "share/zoneinfo/Asia/Dushanbe",
+    "share/zoneinfo/Asia/Famagusta",
+    "share/zoneinfo/Asia/Gaza",
+    "share/zoneinfo/Asia/Harbin",
+    "share/zoneinfo/Asia/Hebron",
+    "share/zoneinfo/Asia/Ho_Chi_Minh",
+    "share/zoneinfo/Asia/Hong_Kong",
+    "share/zoneinfo/Asia/Hovd",
+    "share/zoneinfo/Asia/Irkutsk",
+    "share/zoneinfo/Asia/Istanbul",
+    "share/zoneinfo/Asia/Jakarta",
+    "share/zoneinfo/Asia/Jayapura",
+    "share/zoneinfo/Asia/Jerusalem",
+    "share/zoneinfo/Asia/Kabul",
+    "share/zoneinfo/Asia/Kamchatka",
+    "share/zoneinfo/Asia/Karachi",
+    "share/zoneinfo/Asia/Kashgar",
+    "share/zoneinfo/Asia/Kathmandu",
+    "share/zoneinfo/Asia/Katmandu",
+    "share/zoneinfo/Asia/Khandyga",
+    "share/zoneinfo/Asia/Kolkata",
+    "share/zoneinfo/Asia/Krasnoyarsk",
+    "share/zoneinfo/Asia/Kuala_Lumpur",
+    "share/zoneinfo/Asia/Kuching",
+    "share/zoneinfo/Asia/Kuwait",
+    "share/zoneinfo/Asia/Macao",
+    "share/zoneinfo/Asia/Macau",
+    "share/zoneinfo/Asia/Magadan",
+    "share/zoneinfo/Asia/Makassar",
+    "share/zoneinfo/Asia/Manila",
+    "share/zoneinfo/Asia/Muscat",
+    "share/zoneinfo/Asia/Nicosia",
+    "share/zoneinfo/Asia/Novokuznetsk",
+    "share/zoneinfo/Asia/Novosibirsk",
+    "share/zoneinfo/Asia/Omsk",
+    "share/zoneinfo/Asia/Oral",
+    "share/zoneinfo/Asia/Phnom_Penh",
+    "share/zoneinfo/Asia/Pontianak",
+    "share/zoneinfo/Asia/Pyongyang",
+    "share/zoneinfo/Asia/Qatar",
+    "share/zoneinfo/Asia/Qostanay",
+    "share/zoneinfo/Asia/Qyzylorda",
+    "share/zoneinfo/Asia/Rangoon",
+    "share/zoneinfo/Asia/Riyadh",
+    "share/zoneinfo/Asia/Saigon",
+    "share/zoneinfo/Asia/Sakhalin",
+    "share/zoneinfo/Asia/Samarkand",
+    "share/zoneinfo/Asia/Seoul",
+    "share/zoneinfo/Asia/Shanghai",
+    "share/zoneinfo/Asia/Singapore",
+    "share/zoneinfo/Asia/Srednekolymsk",
+    "share/zoneinfo/Asia/Taipei",
+    "share/zoneinfo/Asia/Tashkent",
+    "share/zoneinfo/Asia/Tbilisi",
+    "share/zoneinfo/Asia/Tehran",
+    "share/zoneinfo/Asia/Tel_Aviv",
+    "share/zoneinfo/Asia/Thimbu",
+    "share/zoneinfo/Asia/Thimphu",
+    "share/zoneinfo/Asia/Tokyo",
+    "share/zoneinfo/Asia/Tomsk",
+    "share/zoneinfo/Asia/Ujung_Pandang",
+    "share/zoneinfo/Asia/Ulaanbaatar",
+    "share/zoneinfo/Asia/Ulan_Bator",
+    "share/zoneinfo/Asia/Urumqi",
+    "share/zoneinfo/Asia/Ust-Nera",
+    "share/zoneinfo/Asia/Vientiane",
+    "share/zoneinfo/Asia/Vladivostok",
+    "share/zoneinfo/Asia/Yakutsk",
+    "share/zoneinfo/Asia/Yangon",
+    "share/zoneinfo/Asia/Yekaterinburg",
+    "share/zoneinfo/Asia/Yerevan",
+    "share/zoneinfo/Atlantic/Azores",
+    "share/zoneinfo/Atlantic/Bermuda",
+    "share/zoneinfo/Atlantic/Canary",
+    "share/zoneinfo/Atlantic/Cape_Verde",
+    "share/zoneinfo/Atlantic/Faeroe",
+    "share/zoneinfo/Atlantic/Faroe",
+    "share/zoneinfo/Atlantic/Jan_Mayen",
+    "share/zoneinfo/Atlantic/Madeira",
+    "share/zoneinfo/Atlantic/Reykjavik",
+    "share/zoneinfo/Atlantic/South_Georgia",
+    "share/zoneinfo/Atlantic/St_Helena",
+    "share/zoneinfo/Atlantic/Stanley",
+    "share/zoneinfo/Australia/ACT",
+    "share/zoneinfo/Australia/Adelaide",
+    "share/zoneinfo/Australia/Brisbane",
+    "share/zoneinfo/Australia/Broken_Hill",
+    "share/zoneinfo/Australia/Canberra",
+    "share/zoneinfo/Australia/Currie",
+    "share/zoneinfo/Australia/Darwin",
+    "share/zoneinfo/Australia/Eucla",
+    "share/zoneinfo/Australia/Hobart",
+    "share/zoneinfo/Australia/LHI",
+    "share/zoneinfo/Australia/Lindeman",
+    "share/zoneinfo/Australia/Lord_Howe",
+    "share/zoneinfo/Australia/Melbourne",
+    "share/zoneinfo/Australia/NSW",
+    "share/zoneinfo/Australia/North",
+    "share/zoneinfo/Australia/Perth",
+    "share/zoneinfo/Australia/Queensland",
+    "share/zoneinfo/Australia/South",
+    "share/zoneinfo/Australia/Sydney",
+    "share/zoneinfo/Australia/Tasmania",
+    "share/zoneinfo/Australia/Victoria",
+    "share/zoneinfo/Australia/West",
+    "share/zoneinfo/Australia/Yancowinna",
+    "share/zoneinfo/Brazil/Acre",
+    "share/zoneinfo/Brazil/DeNoronha",
+    "share/zoneinfo/Brazil/East",
+    "share/zoneinfo/Brazil/West",
+    "share/zoneinfo/CET",
+    "share/zoneinfo/CST6CDT",
+    "share/zoneinfo/Canada/Atlantic",
+    "share/zoneinfo/Canada/Central",
+    "share/zoneinfo/Canada/Eastern",
+    "share/zoneinfo/Canada/Mountain",
+    "share/zoneinfo/Canada/Newfoundland",
+    "share/zoneinfo/Canada/Pacific",
+    "share/zoneinfo/Canada/Saskatchewan",
+    "share/zoneinfo/Canada/Yukon",
+    "share/zoneinfo/Chile/Continental",
+    "share/zoneinfo/Chile/EasterIsland",
+    "share/zoneinfo/Cuba",
+    "share/zoneinfo/EET",
+    "share/zoneinfo/EST",
+    "share/zoneinfo/EST5EDT",
+    "share/zoneinfo/Egypt",
+    "share/zoneinfo/Eire",
+    "share/zoneinfo/Etc/GMT",
+    "share/zoneinfo/Etc/GMT+0",
+    "share/zoneinfo/Etc/GMT+1",
+    "share/zoneinfo/Etc/GMT+10",
+    "share/zoneinfo/Etc/GMT+11",
+    "share/zoneinfo/Etc/GMT+12",
+    "share/zoneinfo/Etc/GMT+2",
+    "share/zoneinfo/Etc/GMT+3",
+    "share/zoneinfo/Etc/GMT+4",
+    "share/zoneinfo/Etc/GMT+5",
+    "share/zoneinfo/Etc/GMT+6",
+    "share/zoneinfo/Etc/GMT+7",
+    "share/zoneinfo/Etc/GMT+8",
+    "share/zoneinfo/Etc/GMT+9",
+    "share/zoneinfo/Etc/GMT-0",
+    "share/zoneinfo/Etc/GMT-1",
+    "share/zoneinfo/Etc/GMT-10",
+    "share/zoneinfo/Etc/GMT-11",
+    "share/zoneinfo/Etc/GMT-12",
+    "share/zoneinfo/Etc/GMT-13",
+    "share/zoneinfo/Etc/GMT-14",
+    "share/zoneinfo/Etc/GMT-2",
+    "share/zoneinfo/Etc/GMT-3",
+    "share/zoneinfo/Etc/GMT-4",
+    "share/zoneinfo/Etc/GMT-5",
+    "share/zoneinfo/Etc/GMT-6",
+    "share/zoneinfo/Etc/GMT-7",
+    "share/zoneinfo/Etc/GMT-8",
+    "share/zoneinfo/Etc/GMT-9",
+    "share/zoneinfo/Etc/GMT0",
+    "share/zoneinfo/Etc/Greenwich",
+    "share/zoneinfo/Etc/UCT",
+    "share/zoneinfo/Etc/UTC",
+    "share/zoneinfo/Etc/Universal",
+    "share/zoneinfo/Etc/Zulu",
+    "share/zoneinfo/Europe/Amsterdam",
+    "share/zoneinfo/Europe/Andorra",
+    "share/zoneinfo/Europe/Astrakhan",
+    "share/zoneinfo/Europe/Athens",
+    "share/zoneinfo/Europe/Belfast",
+    "share/zoneinfo/Europe/Belgrade",
+    "share/zoneinfo/Europe/Berlin",
+    "share/zoneinfo/Europe/Bratislava",
+    "share/zoneinfo/Europe/Brussels",
+    "share/zoneinfo/Europe/Bucharest",
+    "share/zoneinfo/Europe/Budapest",
+    "share/zoneinfo/Europe/Busingen",
+    "share/zoneinfo/Europe/Chisinau",
+    "share/zoneinfo/Europe/Copenhagen",
+    "share/zoneinfo/Europe/Dublin",
+    "share/zoneinfo/Europe/Gibraltar",
+    "share/zoneinfo/Europe/Guernsey",
+    "share/zoneinfo/Europe/Helsinki",
+    "share/zoneinfo/Europe/Isle_of_Man",
+    "share/zoneinfo/Europe/Istanbul",
+    "share/zoneinfo/Europe/Jersey",
+    "share/zoneinfo/Europe/Kaliningrad",
+    "share/zoneinfo/Europe/Kiev",
+    "share/zoneinfo/Europe/Kirov",
+    "share/zoneinfo/Europe/Kyiv",
+    "share/zoneinfo/Europe/Lisbon",
+    "share/zoneinfo/Europe/Ljubljana",
+    "share/zoneinfo/Europe/London",
+    "share/zoneinfo/Europe/Luxembourg",
+    "share/zoneinfo/Europe/Madrid",
+    "share/zoneinfo/Europe/Malta",
+    "share/zoneinfo/Europe/Mariehamn",
+    "share/zoneinfo/Europe/Minsk",
+    "share/zoneinfo/Europe/Monaco",
+    "share/zoneinfo/Europe/Moscow",
+    "share/zoneinfo/Europe/Nicosia",
+    "share/zoneinfo/Europe/Oslo",
+    "share/zoneinfo/Europe/Paris",
+    "share/zoneinfo/Europe/Podgorica",
+    "share/zoneinfo/Europe/Prague",
+    "share/zoneinfo/Europe/Riga",
+    "share/zoneinfo/Europe/Rome",
+    "share/zoneinfo/Europe/Samara",
+    "share/zoneinfo/Europe/San_Marino",
+    "share/zoneinfo/Europe/Sarajevo",
+    "share/zoneinfo/Europe/Saratov",
+    "share/zoneinfo/Europe/Simferopol",
+    "share/zoneinfo/Europe/Skopje",
+    "share/zoneinfo/Europe/Sofia",
+    "share/zoneinfo/Europe/Stockholm",
+    "share/zoneinfo/Europe/Tallinn",
+    "share/zoneinfo/Europe/Tirane",
+    "share/zoneinfo/Europe/Tiraspol",
+    "share/zoneinfo/Europe/Ulyanovsk",
+    "share/zoneinfo/Europe/Uzhgorod",
+    "share/zoneinfo/Europe/Vaduz",
+    "share/zoneinfo/Europe/Vatican",
+    "share/zoneinfo/Europe/Vienna",
+    "share/zoneinfo/Europe/Vilnius",
+    "share/zoneinfo/Europe/Volgograd",
+    "share/zoneinfo/Europe/Warsaw",
+    "share/zoneinfo/Europe/Zagreb",
+    "share/zoneinfo/Europe/Zaporozhye",
+    "share/zoneinfo/Europe/Zurich",
+    "share/zoneinfo/Factory",
+    "share/zoneinfo/GB",
+    "share/zoneinfo/GB-Eire",
+    "share/zoneinfo/GMT",
+    "share/zoneinfo/GMT+0",
+    "share/zoneinfo/GMT-0",
+    "share/zoneinfo/GMT0",
+    "share/zoneinfo/Greenwich",
+    "share/zoneinfo/HST",
+    "share/zoneinfo/Hongkong",
+    "share/zoneinfo/Iceland",
+    "share/zoneinfo/Indian/Antananarivo",
+    "share/zoneinfo/Indian/Chagos",
+    "share/zoneinfo/Indian/Christmas",
+    "share/zoneinfo/Indian/Cocos",
+    "share/zoneinfo/Indian/Comoro",
+    "share/zoneinfo/Indian/Kerguelen",
+    "share/zoneinfo/Indian/Mahe",
+    "share/zoneinfo/Indian/Maldives",
+    "share/zoneinfo/Indian/Mauritius",
+    "share/zoneinfo/Indian/Mayotte",
+    "share/zoneinfo/Indian/Reunion",
+    "share/zoneinfo/Iran",
+    "share/zoneinfo/Israel",
+    "share/zoneinfo/Jamaica",
+    "share/zoneinfo/Japan",
+    "share/zoneinfo/Kwajalein",
+    "share/zoneinfo/Libya",
+    "share/zoneinfo/MET",
+    "share/zoneinfo/MST",
+    "share/zoneinfo/MST7MDT",
+    "share/zoneinfo/Mexico/BajaNorte",
+    "share/zoneinfo/Mexico/BajaSur",
+    "share/zoneinfo/Mexico/General",
+    "share/zoneinfo/NZ",
+    "share/zoneinfo/NZ-CHAT",
+    "share/zoneinfo/Navajo",
+    "share/zoneinfo/PRC",
+    "share/zoneinfo/PST8PDT",
+    "share/zoneinfo/Pacific/Apia",
+    "share/zoneinfo/Pacific/Auckland",
+    "share/zoneinfo/Pacific/Bougainville",
+    "share/zoneinfo/Pacific/Chatham",
+    "share/zoneinfo/Pacific/Chuuk",
+    "share/zoneinfo/Pacific/Easter",
+    "share/zoneinfo/Pacific/Efate",
+    "share/zoneinfo/Pacific/Enderbury",
+    "share/zoneinfo/Pacific/Fakaofo",
+    "share/zoneinfo/Pacific/Fiji",
+    "share/zoneinfo/Pacific/Funafuti",
+    "share/zoneinfo/Pacific/Galapagos",
+    "share/zoneinfo/Pacific/Gambier",
+    "share/zoneinfo/Pacific/Guadalcanal",
+    "share/zoneinfo/Pacific/Guam",
+    "share/zoneinfo/Pacific/Honolulu",
+    "share/zoneinfo/Pacific/Johnston",
+    "share/zoneinfo/Pacific/Kanton",
+    "share/zoneinfo/Pacific/Kiritimati",
+    "share/zoneinfo/Pacific/Kosrae",
+    "share/zoneinfo/Pacific/Kwajalein",
+    "share/zoneinfo/Pacific/Majuro",
+    "share/zoneinfo/Pacific/Marquesas",
+    "share/zoneinfo/Pacific/Midway",
+    "share/zoneinfo/Pacific/Nauru",
+    "share/zoneinfo/Pacific/Niue",
+    "share/zoneinfo/Pacific/Norfolk",
+    "share/zoneinfo/Pacific/Noumea",
+    "share/zoneinfo/Pacific/Pago_Pago",
+    "share/zoneinfo/Pacific/Palau",
+    "share/zoneinfo/Pacific/Pitcairn",
+    "share/zoneinfo/Pacific/Pohnpei",
+    "share/zoneinfo/Pacific/Ponape",
+    "share/zoneinfo/Pacific/Port_Moresby",
+    "share/zoneinfo/Pacific/Rarotonga",
+    "share/zoneinfo/Pacific/Saipan",
+    "share/zoneinfo/Pacific/Samoa",
+    "share/zoneinfo/Pacific/Tahiti",
+    "share/zoneinfo/Pacific/Tarawa",
+    "share/zoneinfo/Pacific/Tongatapu",
+    "share/zoneinfo/Pacific/Truk",
+    "share/zoneinfo/Pacific/Wake",
+    "share/zoneinfo/Pacific/Wallis",
+    "share/zoneinfo/Pacific/Yap",
+    "share/zoneinfo/Poland",
+    "share/zoneinfo/Portugal",
+    "share/zoneinfo/ROC",
+    "share/zoneinfo/ROK",
+    "share/zoneinfo/Singapore",
+    "share/zoneinfo/Turkey",
+    "share/zoneinfo/UCT",
+    "share/zoneinfo/US/Alaska",
+    "share/zoneinfo/US/Aleutian",
+    "share/zoneinfo/US/Arizona",
+    "share/zoneinfo/US/Central",
+    "share/zoneinfo/US/East-Indiana",
+    "share/zoneinfo/US/Eastern",
+    "share/zoneinfo/US/Hawaii",
+    "share/zoneinfo/US/Indiana-Starke",
+    "share/zoneinfo/US/Michigan",
+    "share/zoneinfo/US/Mountain",
+    "share/zoneinfo/US/Pacific",
+    "share/zoneinfo/US/Samoa",
+    "share/zoneinfo/UTC",
+    "share/zoneinfo/Universal",
+    "share/zoneinfo/W-SU",
+    "share/zoneinfo/WET",
+    "share/zoneinfo/Zulu",
+    "share/zoneinfo/build/etc/localtime",
+    "share/zoneinfo/iso3166.tab",
+    "share/zoneinfo/leap-seconds.list",
+    "share/zoneinfo/leapseconds",
+    "share/zoneinfo/tzdata.zi",
+    "share/zoneinfo/zone.tab",
+    "share/zoneinfo/zone1970.tab",
+    "share/zoneinfo/zonenow.tab",
+    ".nonadmin"
+  ],
+  "fn": "tzdata-2025a-h04d1e81_0.conda",
+  "legacy_bz2_md5": "200a475b8b5b4e72e8b5ceddf3d0f24a",
+  "license": "CC-PDDC OR BSD-3-Clause",
+  "license_family": "BSD",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\tzdata-2025a-h04d1e81_0",
+    "type": 1
+  },
+  "md5": "885caf42f821b98b3321dc4108511a3d",
+  "name": "tzdata",
+  "noarch": "generic",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\tzdata-2025a-h04d1e81_0.conda",
+  "package_type": "noarch_generic",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "share/zoneinfo/Africa/Abidjan",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Accra",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Addis_Ababa",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Algiers",
+        "path_type": "hardlink",
+        "sha256": "2f69d2e202cd16fba8f3da7762d07e9520d8636dbce12aa4187f6941023cbb07",
+        "sha256_in_prefix": "2f69d2e202cd16fba8f3da7762d07e9520d8636dbce12aa4187f6941023cbb07",
+        "size_in_bytes": 470
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Asmara",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Asmera",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Bamako",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Bangui",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Banjul",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Bissau",
+        "path_type": "hardlink",
+        "sha256": "c1adeebdad76f5d2474428bbb58b74e2414e9f5fa8b0c4b669f32395e3bd983c",
+        "sha256_in_prefix": "c1adeebdad76f5d2474428bbb58b74e2414e9f5fa8b0c4b669f32395e3bd983c",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Blantyre",
+        "path_type": "hardlink",
+        "sha256": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "sha256_in_prefix": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "size_in_bytes": 131
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Brazzaville",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Bujumbura",
+        "path_type": "hardlink",
+        "sha256": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "sha256_in_prefix": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "size_in_bytes": 131
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Cairo",
+        "path_type": "hardlink",
+        "sha256": "89cb9a36212fb82e933dcd9faa10efdfa969a29ec80c32063bbb4518c033d1be",
+        "sha256_in_prefix": "89cb9a36212fb82e933dcd9faa10efdfa969a29ec80c32063bbb4518c033d1be",
+        "size_in_bytes": 1309
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Casablanca",
+        "path_type": "hardlink",
+        "sha256": "30ca6cf13e00c2a6c437a3c837fa643623cc04406ab5165165c78b37ef6bc4c3",
+        "sha256_in_prefix": "30ca6cf13e00c2a6c437a3c837fa643623cc04406ab5165165c78b37ef6bc4c3",
+        "size_in_bytes": 1919
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Ceuta",
+        "path_type": "hardlink",
+        "sha256": "a042202b9dda7f3d52631601fc3d2347df12b37839f35c9bf139cba693da61c6",
+        "sha256_in_prefix": "a042202b9dda7f3d52631601fc3d2347df12b37839f35c9bf139cba693da61c6",
+        "size_in_bytes": 562
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Conakry",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Dakar",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Dar_es_Salaam",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Djibouti",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Douala",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/El_Aaiun",
+        "path_type": "hardlink",
+        "sha256": "ea17cb6cb7eb0f5432f5966a2d7af55f0edfcde12cfc5a9e1cddb36496545492",
+        "sha256_in_prefix": "ea17cb6cb7eb0f5432f5966a2d7af55f0edfcde12cfc5a9e1cddb36496545492",
+        "size_in_bytes": 1830
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Freetown",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Gaborone",
+        "path_type": "hardlink",
+        "sha256": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "sha256_in_prefix": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "size_in_bytes": 131
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Harare",
+        "path_type": "hardlink",
+        "sha256": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "sha256_in_prefix": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "size_in_bytes": 131
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Johannesburg",
+        "path_type": "hardlink",
+        "sha256": "d19aebe2435c4e84bf7ae65533d23a9d440f98162e5b4d69c73f783e02299ec8",
+        "sha256_in_prefix": "d19aebe2435c4e84bf7ae65533d23a9d440f98162e5b4d69c73f783e02299ec8",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Juba",
+        "path_type": "hardlink",
+        "sha256": "553a683003fe8c9e9c2ac0de355afb9772ca1a8283531194d9bd60aaf0cfcf7e",
+        "sha256_in_prefix": "553a683003fe8c9e9c2ac0de355afb9772ca1a8283531194d9bd60aaf0cfcf7e",
+        "size_in_bytes": 458
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Kampala",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Khartoum",
+        "path_type": "hardlink",
+        "sha256": "351c0ec08838491e97b83d75937871073efbba8069cde8d7abbbf1b6ad97cacf",
+        "sha256_in_prefix": "351c0ec08838491e97b83d75937871073efbba8069cde8d7abbbf1b6ad97cacf",
+        "size_in_bytes": 458
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Kigali",
+        "path_type": "hardlink",
+        "sha256": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "sha256_in_prefix": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "size_in_bytes": 131
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Kinshasa",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Lagos",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Libreville",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Lome",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Luanda",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Lubumbashi",
+        "path_type": "hardlink",
+        "sha256": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "sha256_in_prefix": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "size_in_bytes": 131
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Lusaka",
+        "path_type": "hardlink",
+        "sha256": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "sha256_in_prefix": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "size_in_bytes": 131
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Malabo",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Maputo",
+        "path_type": "hardlink",
+        "sha256": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "sha256_in_prefix": "910c97c091cd34ae7427c83226234ce7b4f2f425c5822d6669c24be62010a792",
+        "size_in_bytes": 131
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Maseru",
+        "path_type": "hardlink",
+        "sha256": "d19aebe2435c4e84bf7ae65533d23a9d440f98162e5b4d69c73f783e02299ec8",
+        "sha256_in_prefix": "d19aebe2435c4e84bf7ae65533d23a9d440f98162e5b4d69c73f783e02299ec8",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Mbabane",
+        "path_type": "hardlink",
+        "sha256": "d19aebe2435c4e84bf7ae65533d23a9d440f98162e5b4d69c73f783e02299ec8",
+        "sha256_in_prefix": "d19aebe2435c4e84bf7ae65533d23a9d440f98162e5b4d69c73f783e02299ec8",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Mogadishu",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Monrovia",
+        "path_type": "hardlink",
+        "sha256": "58cf8955faf9d36560cb5f057ba880276c8c80e59bc30ba621087fca9e7778a3",
+        "sha256_in_prefix": "58cf8955faf9d36560cb5f057ba880276c8c80e59bc30ba621087fca9e7778a3",
+        "size_in_bytes": 164
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Nairobi",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Ndjamena",
+        "path_type": "hardlink",
+        "sha256": "4e58f865450d271121bc0a28ed324aa96bf527bb4461a7f514431ecfe2bdc448",
+        "sha256_in_prefix": "4e58f865450d271121bc0a28ed324aa96bf527bb4461a7f514431ecfe2bdc448",
+        "size_in_bytes": 160
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Niamey",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Nouakchott",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Ouagadougou",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Porto-Novo",
+        "path_type": "hardlink",
+        "sha256": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "sha256_in_prefix": "e5ef1288571cc56c5276ca966e1c8a675c6747726d758ecafe7effce6eca7be4",
+        "size_in_bytes": 180
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Sao_Tome",
+        "path_type": "hardlink",
+        "sha256": "3df8aeb5a930e41e71af5392835b85bd3d06c02ea354eaaac67c7af46109bb9d",
+        "sha256_in_prefix": "3df8aeb5a930e41e71af5392835b85bd3d06c02ea354eaaac67c7af46109bb9d",
+        "size_in_bytes": 173
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Timbuktu",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Tripoli",
+        "path_type": "hardlink",
+        "sha256": "cf33012d9661e15438fc045ee64e0bfebb2ea8a3fb79d2af56df05ea4be3e453",
+        "sha256_in_prefix": "cf33012d9661e15438fc045ee64e0bfebb2ea8a3fb79d2af56df05ea4be3e453",
+        "size_in_bytes": 431
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Tunis",
+        "path_type": "hardlink",
+        "sha256": "ba8004111e3c449a8d786a1806e93921e62a8dcf2c1ef58bbcab2cb9509dd7c8",
+        "sha256_in_prefix": "ba8004111e3c449a8d786a1806e93921e62a8dcf2c1ef58bbcab2cb9509dd7c8",
+        "size_in_bytes": 449
+      },
+      {
+        "_path": "share/zoneinfo/Africa/Windhoek",
+        "path_type": "hardlink",
+        "sha256": "8358cb464a3fda9786b144e0d3fc19c9c382e20c53007c1f57648ef48dca7423",
+        "sha256_in_prefix": "8358cb464a3fda9786b144e0d3fc19c9c382e20c53007c1f57648ef48dca7423",
+        "size_in_bytes": 638
+      },
+      {
+        "_path": "share/zoneinfo/America/Adak",
+        "path_type": "hardlink",
+        "sha256": "abfb1980e20d5f84ec5fd881c7580d77a5c6c019f30a383aaa97404212b489e0",
+        "sha256_in_prefix": "abfb1980e20d5f84ec5fd881c7580d77a5c6c019f30a383aaa97404212b489e0",
+        "size_in_bytes": 969
+      },
+      {
+        "_path": "share/zoneinfo/America/Anchorage",
+        "path_type": "hardlink",
+        "sha256": "77ca0c22962f06998bce5e48d81cb865a14466c83ff5dc607eaa483344058bf6",
+        "sha256_in_prefix": "77ca0c22962f06998bce5e48d81cb865a14466c83ff5dc607eaa483344058bf6",
+        "size_in_bytes": 977
+      },
+      {
+        "_path": "share/zoneinfo/America/Anguilla",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Antigua",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Araguaina",
+        "path_type": "hardlink",
+        "sha256": "4dac185f8955031ab40715068530f1e02f2fb414672ee5a2f2a2d5fe85c3894a",
+        "sha256_in_prefix": "4dac185f8955031ab40715068530f1e02f2fb414672ee5a2f2a2d5fe85c3894a",
+        "size_in_bytes": 592
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/Buenos_Aires",
+        "path_type": "hardlink",
+        "sha256": "20454ea527c8ea888926614d21bf556f46ce38c220c4ee5b821170eef9071469",
+        "sha256_in_prefix": "20454ea527c8ea888926614d21bf556f46ce38c220c4ee5b821170eef9071469",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/Catamarca",
+        "path_type": "hardlink",
+        "sha256": "502d1fc71ed93e68cfc370f404afb9bdaa7e735701cdb811dbddcc76611f3b1d",
+        "sha256_in_prefix": "502d1fc71ed93e68cfc370f404afb9bdaa7e735701cdb811dbddcc76611f3b1d",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/ComodRivadavia",
+        "path_type": "hardlink",
+        "sha256": "502d1fc71ed93e68cfc370f404afb9bdaa7e735701cdb811dbddcc76611f3b1d",
+        "sha256_in_prefix": "502d1fc71ed93e68cfc370f404afb9bdaa7e735701cdb811dbddcc76611f3b1d",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/Cordoba",
+        "path_type": "hardlink",
+        "sha256": "f488f75a34fd99630a438dcb792508a90b836fdcd2dc54a51d83d535025315fd",
+        "sha256_in_prefix": "f488f75a34fd99630a438dcb792508a90b836fdcd2dc54a51d83d535025315fd",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/Jujuy",
+        "path_type": "hardlink",
+        "sha256": "ed8a6339c99568a2a98aadf5ad07bc4d30cd131747f638d922175c66ff928548",
+        "sha256_in_prefix": "ed8a6339c99568a2a98aadf5ad07bc4d30cd131747f638d922175c66ff928548",
+        "size_in_bytes": 690
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/La_Rioja",
+        "path_type": "hardlink",
+        "sha256": "9949110f98da589532d9ff2f345a8e94c80a3e9b542ce067faf7ff8cc805eb1f",
+        "sha256_in_prefix": "9949110f98da589532d9ff2f345a8e94c80a3e9b542ce067faf7ff8cc805eb1f",
+        "size_in_bytes": 717
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/Mendoza",
+        "path_type": "hardlink",
+        "sha256": "74be2ad33818d8528f6c6f1c0be5a49e7a69f2d17663b496816482fc6fd6ce72",
+        "sha256_in_prefix": "74be2ad33818d8528f6c6f1c0be5a49e7a69f2d17663b496816482fc6fd6ce72",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/Rio_Gallegos",
+        "path_type": "hardlink",
+        "sha256": "6c2a56325108f0a59ee1cde7e9f9fcbba5823e7c6362d572e7b111b4b4d9684b",
+        "sha256_in_prefix": "6c2a56325108f0a59ee1cde7e9f9fcbba5823e7c6362d572e7b111b4b4d9684b",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/Salta",
+        "path_type": "hardlink",
+        "sha256": "1ffc9bc55c9c7ce7bb2e5500dc69e0a12d2310d1e44144484618df25017691f5",
+        "sha256_in_prefix": "1ffc9bc55c9c7ce7bb2e5500dc69e0a12d2310d1e44144484618df25017691f5",
+        "size_in_bytes": 690
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/San_Juan",
+        "path_type": "hardlink",
+        "sha256": "323e6f214cd09790edb0f7b788ccd2eeb47ef3c53d1ca5b672c42a51d6b824d3",
+        "sha256_in_prefix": "323e6f214cd09790edb0f7b788ccd2eeb47ef3c53d1ca5b672c42a51d6b824d3",
+        "size_in_bytes": 717
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/San_Luis",
+        "path_type": "hardlink",
+        "sha256": "ae46bc068928832bcc4451fa8ebf03eacd6d148a6c51ea8727f7de2cae4ee9db",
+        "sha256_in_prefix": "ae46bc068928832bcc4451fa8ebf03eacd6d148a6c51ea8727f7de2cae4ee9db",
+        "size_in_bytes": 717
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/Tucuman",
+        "path_type": "hardlink",
+        "sha256": "cafdda0be8402cb8a8db2aa778b208ca56615ca0e56cf24601dfda6e0b23f608",
+        "sha256_in_prefix": "cafdda0be8402cb8a8db2aa778b208ca56615ca0e56cf24601dfda6e0b23f608",
+        "size_in_bytes": 726
+      },
+      {
+        "_path": "share/zoneinfo/America/Argentina/Ushuaia",
+        "path_type": "hardlink",
+        "sha256": "99c999801d691075fa8bb9e5c91ce32e71bc6ea02d00ad53c0c7510f6a59a811",
+        "sha256_in_prefix": "99c999801d691075fa8bb9e5c91ce32e71bc6ea02d00ad53c0c7510f6a59a811",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Aruba",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Asuncion",
+        "path_type": "hardlink",
+        "sha256": "dc938d02e787eca6bfc6ae4a3ab72d2a42806ae3dedc14e0d01393040f143542",
+        "sha256_in_prefix": "dc938d02e787eca6bfc6ae4a3ab72d2a42806ae3dedc14e0d01393040f143542",
+        "size_in_bytes": 1085
+      },
+      {
+        "_path": "share/zoneinfo/America/Atikokan",
+        "path_type": "hardlink",
+        "sha256": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "sha256_in_prefix": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "share/zoneinfo/America/Atka",
+        "path_type": "hardlink",
+        "sha256": "abfb1980e20d5f84ec5fd881c7580d77a5c6c019f30a383aaa97404212b489e0",
+        "sha256_in_prefix": "abfb1980e20d5f84ec5fd881c7580d77a5c6c019f30a383aaa97404212b489e0",
+        "size_in_bytes": 969
+      },
+      {
+        "_path": "share/zoneinfo/America/Bahia",
+        "path_type": "hardlink",
+        "sha256": "ffe645c3e1f35dcedbc9a7075bf3491ed274dc00c576ab7591a620c966286d8c",
+        "sha256_in_prefix": "ffe645c3e1f35dcedbc9a7075bf3491ed274dc00c576ab7591a620c966286d8c",
+        "size_in_bytes": 682
+      },
+      {
+        "_path": "share/zoneinfo/America/Bahia_Banderas",
+        "path_type": "hardlink",
+        "sha256": "949f0af8fad4a8b4de7eeaa970aa7f616bdfbf31f458d36b67f2c87a5ff4a194",
+        "sha256_in_prefix": "949f0af8fad4a8b4de7eeaa970aa7f616bdfbf31f458d36b67f2c87a5ff4a194",
+        "size_in_bytes": 700
+      },
+      {
+        "_path": "share/zoneinfo/America/Barbados",
+        "path_type": "hardlink",
+        "sha256": "81d8897fd64a38cb3d401e1ec74f9caef76684d7c7a4dcd74d5db14da3430808",
+        "sha256_in_prefix": "81d8897fd64a38cb3d401e1ec74f9caef76684d7c7a4dcd74d5db14da3430808",
+        "size_in_bytes": 278
+      },
+      {
+        "_path": "share/zoneinfo/America/Belem",
+        "path_type": "hardlink",
+        "sha256": "c348effa07416c4059401176cf69622a944cf4210e580dfa3b5a94d6724a782b",
+        "sha256_in_prefix": "c348effa07416c4059401176cf69622a944cf4210e580dfa3b5a94d6724a782b",
+        "size_in_bytes": 394
+      },
+      {
+        "_path": "share/zoneinfo/America/Belize",
+        "path_type": "hardlink",
+        "sha256": "b9804f26a9c21a738e78a9e8cf5206f4f3964ef5c3e64522ae916e0743c78d5a",
+        "sha256_in_prefix": "b9804f26a9c21a738e78a9e8cf5206f4f3964ef5c3e64522ae916e0743c78d5a",
+        "size_in_bytes": 1045
+      },
+      {
+        "_path": "share/zoneinfo/America/Blanc-Sablon",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Boa_Vista",
+        "path_type": "hardlink",
+        "sha256": "8584c514d35925d97f9d260875f23c49086d99f89a92308323fd794e507ec44c",
+        "sha256_in_prefix": "8584c514d35925d97f9d260875f23c49086d99f89a92308323fd794e507ec44c",
+        "size_in_bytes": 430
+      },
+      {
+        "_path": "share/zoneinfo/America/Bogota",
+        "path_type": "hardlink",
+        "sha256": "06a1fab8296bae54fe56c06691ed8c87e21f035475975874df50915122d2d67a",
+        "sha256_in_prefix": "06a1fab8296bae54fe56c06691ed8c87e21f035475975874df50915122d2d67a",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "share/zoneinfo/America/Boise",
+        "path_type": "hardlink",
+        "sha256": "26dde89b23d23d1a0a13e29755dfb0c5538df820c4e6819a240ec0afdd10d8e3",
+        "sha256_in_prefix": "26dde89b23d23d1a0a13e29755dfb0c5538df820c4e6819a240ec0afdd10d8e3",
+        "size_in_bytes": 999
+      },
+      {
+        "_path": "share/zoneinfo/America/Buenos_Aires",
+        "path_type": "hardlink",
+        "sha256": "20454ea527c8ea888926614d21bf556f46ce38c220c4ee5b821170eef9071469",
+        "sha256_in_prefix": "20454ea527c8ea888926614d21bf556f46ce38c220c4ee5b821170eef9071469",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Cambridge_Bay",
+        "path_type": "hardlink",
+        "sha256": "345c0d55f8316f660c2f373ee36440f922ad35c383a6e9047d87ff4165984ec2",
+        "sha256_in_prefix": "345c0d55f8316f660c2f373ee36440f922ad35c383a6e9047d87ff4165984ec2",
+        "size_in_bytes": 883
+      },
+      {
+        "_path": "share/zoneinfo/America/Campo_Grande",
+        "path_type": "hardlink",
+        "sha256": "9a780a623687fc4355989fa6b544558e3168e641e02df60d3c765a0954b14051",
+        "sha256_in_prefix": "9a780a623687fc4355989fa6b544558e3168e641e02df60d3c765a0954b14051",
+        "size_in_bytes": 952
+      },
+      {
+        "_path": "share/zoneinfo/America/Cancun",
+        "path_type": "hardlink",
+        "sha256": "612a14c5b8da2f633270a0930776402bd8cf55a78c856ecc90e100f1e59a90a6",
+        "sha256_in_prefix": "612a14c5b8da2f633270a0930776402bd8cf55a78c856ecc90e100f1e59a90a6",
+        "size_in_bytes": 538
+      },
+      {
+        "_path": "share/zoneinfo/America/Caracas",
+        "path_type": "hardlink",
+        "sha256": "507994c1cd2614fa22751e140c259be13e30fe6a4206c49be01916dd238a2156",
+        "sha256_in_prefix": "507994c1cd2614fa22751e140c259be13e30fe6a4206c49be01916dd238a2156",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "share/zoneinfo/America/Catamarca",
+        "path_type": "hardlink",
+        "sha256": "502d1fc71ed93e68cfc370f404afb9bdaa7e735701cdb811dbddcc76611f3b1d",
+        "sha256_in_prefix": "502d1fc71ed93e68cfc370f404afb9bdaa7e735701cdb811dbddcc76611f3b1d",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Cayenne",
+        "path_type": "hardlink",
+        "sha256": "f54454e28d6fe7be7d516ba1f3123dbe768034e71e39e456ebb5e8190bae51af",
+        "sha256_in_prefix": "f54454e28d6fe7be7d516ba1f3123dbe768034e71e39e456ebb5e8190bae51af",
+        "size_in_bytes": 151
+      },
+      {
+        "_path": "share/zoneinfo/America/Cayman",
+        "path_type": "hardlink",
+        "sha256": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "sha256_in_prefix": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "share/zoneinfo/America/Chicago",
+        "path_type": "hardlink",
+        "sha256": "c27b739ff46a7df0594e120d725b439217e11e44ea9a50cdc49130383b5482e7",
+        "sha256_in_prefix": "c27b739ff46a7df0594e120d725b439217e11e44ea9a50cdc49130383b5482e7",
+        "size_in_bytes": 1754
+      },
+      {
+        "_path": "share/zoneinfo/America/Chihuahua",
+        "path_type": "hardlink",
+        "sha256": "b733a603bb6b845ca4c9467b41bb8c03a03cf01485da8e26ba6a3ae5aa23ceaa",
+        "sha256_in_prefix": "b733a603bb6b845ca4c9467b41bb8c03a03cf01485da8e26ba6a3ae5aa23ceaa",
+        "size_in_bytes": 691
+      },
+      {
+        "_path": "share/zoneinfo/America/Ciudad_Juarez",
+        "path_type": "hardlink",
+        "sha256": "98413e54dfaca950da1c52721465016323ac607091b2951971226ab76e96b9f8",
+        "sha256_in_prefix": "98413e54dfaca950da1c52721465016323ac607091b2951971226ab76e96b9f8",
+        "size_in_bytes": 718
+      },
+      {
+        "_path": "share/zoneinfo/America/Coral_Harbour",
+        "path_type": "hardlink",
+        "sha256": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "sha256_in_prefix": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "share/zoneinfo/America/Cordoba",
+        "path_type": "hardlink",
+        "sha256": "f488f75a34fd99630a438dcb792508a90b836fdcd2dc54a51d83d535025315fd",
+        "sha256_in_prefix": "f488f75a34fd99630a438dcb792508a90b836fdcd2dc54a51d83d535025315fd",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Costa_Rica",
+        "path_type": "hardlink",
+        "sha256": "8a1a2a03fb479989b46234d12d9bb7abc3eab2aa8e79bd4210b8d684f7ff1d71",
+        "sha256_in_prefix": "8a1a2a03fb479989b46234d12d9bb7abc3eab2aa8e79bd4210b8d684f7ff1d71",
+        "size_in_bytes": 232
+      },
+      {
+        "_path": "share/zoneinfo/America/Creston",
+        "path_type": "hardlink",
+        "sha256": "ae11453c21d08984de75f2efec04dc93178a7b4e23c5e52f2098b8bd45ccb547",
+        "sha256_in_prefix": "ae11453c21d08984de75f2efec04dc93178a7b4e23c5e52f2098b8bd45ccb547",
+        "size_in_bytes": 240
+      },
+      {
+        "_path": "share/zoneinfo/America/Cuiaba",
+        "path_type": "hardlink",
+        "sha256": "39a2257b40abf8129ed213a2939af075ca026d0e4b487907a814b670ba02a805",
+        "sha256_in_prefix": "39a2257b40abf8129ed213a2939af075ca026d0e4b487907a814b670ba02a805",
+        "size_in_bytes": 934
+      },
+      {
+        "_path": "share/zoneinfo/America/Curacao",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Danmarkshavn",
+        "path_type": "hardlink",
+        "sha256": "710391b80f29474bf0dd9c187de1a459a4f5b4f53aea7310db144a4f54f561be",
+        "sha256_in_prefix": "710391b80f29474bf0dd9c187de1a459a4f5b4f53aea7310db144a4f54f561be",
+        "size_in_bytes": 447
+      },
+      {
+        "_path": "share/zoneinfo/America/Dawson",
+        "path_type": "hardlink",
+        "sha256": "065295d14dfa8ea9e5c4ce7e3f19fc388898e6424470b96ddd0668f86b0cce56",
+        "sha256_in_prefix": "065295d14dfa8ea9e5c4ce7e3f19fc388898e6424470b96ddd0668f86b0cce56",
+        "size_in_bytes": 1029
+      },
+      {
+        "_path": "share/zoneinfo/America/Dawson_Creek",
+        "path_type": "hardlink",
+        "sha256": "b7851232e22fab55552fd81809a6eb68062cdf592602a027c1fec6cc488924d7",
+        "sha256_in_prefix": "b7851232e22fab55552fd81809a6eb68062cdf592602a027c1fec6cc488924d7",
+        "size_in_bytes": 683
+      },
+      {
+        "_path": "share/zoneinfo/America/Denver",
+        "path_type": "hardlink",
+        "sha256": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "sha256_in_prefix": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "size_in_bytes": 1042
+      },
+      {
+        "_path": "share/zoneinfo/America/Detroit",
+        "path_type": "hardlink",
+        "sha256": "23817c32df67c77f0017a0feb2d798b2405afc71ceea3294d7e5b4c9116be740",
+        "sha256_in_prefix": "23817c32df67c77f0017a0feb2d798b2405afc71ceea3294d7e5b4c9116be740",
+        "size_in_bytes": 899
+      },
+      {
+        "_path": "share/zoneinfo/America/Dominica",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Edmonton",
+        "path_type": "hardlink",
+        "sha256": "0eada6c5c48d59984c591ab1c30b4c71aab000818cc243b3cfe996f1f26c715f",
+        "sha256_in_prefix": "0eada6c5c48d59984c591ab1c30b4c71aab000818cc243b3cfe996f1f26c715f",
+        "size_in_bytes": 970
+      },
+      {
+        "_path": "share/zoneinfo/America/Eirunepe",
+        "path_type": "hardlink",
+        "sha256": "ead298691a676c14a65e2c17cbbfe6e165bfadb55f9f92d479cd24782dc9ec8c",
+        "sha256_in_prefix": "ead298691a676c14a65e2c17cbbfe6e165bfadb55f9f92d479cd24782dc9ec8c",
+        "size_in_bytes": 436
+      },
+      {
+        "_path": "share/zoneinfo/America/El_Salvador",
+        "path_type": "hardlink",
+        "sha256": "e308ec0a9447f40164e5a6cb01b9eebfece8ba144a7306f469e9e4fa75ad9b3d",
+        "sha256_in_prefix": "e308ec0a9447f40164e5a6cb01b9eebfece8ba144a7306f469e9e4fa75ad9b3d",
+        "size_in_bytes": 176
+      },
+      {
+        "_path": "share/zoneinfo/America/Ensenada",
+        "path_type": "hardlink",
+        "sha256": "3065abfbab680d16ab8cc5d36a23885a004558d6f0ee51ef89d2ee3ca1717c8a",
+        "sha256_in_prefix": "3065abfbab680d16ab8cc5d36a23885a004558d6f0ee51ef89d2ee3ca1717c8a",
+        "size_in_bytes": 1079
+      },
+      {
+        "_path": "share/zoneinfo/America/Fort_Nelson",
+        "path_type": "hardlink",
+        "sha256": "fe3ec827e8571ed57fedd48c83aa711902dbeb3fc8694323dda25d7bf178f504",
+        "sha256_in_prefix": "fe3ec827e8571ed57fedd48c83aa711902dbeb3fc8694323dda25d7bf178f504",
+        "size_in_bytes": 1448
+      },
+      {
+        "_path": "share/zoneinfo/America/Fort_Wayne",
+        "path_type": "hardlink",
+        "sha256": "e678f42a13efbd7be0f26a9ce53e04b1c28a582eab05611cb01c16836432f07b",
+        "sha256_in_prefix": "e678f42a13efbd7be0f26a9ce53e04b1c28a582eab05611cb01c16836432f07b",
+        "size_in_bytes": 531
+      },
+      {
+        "_path": "share/zoneinfo/America/Fortaleza",
+        "path_type": "hardlink",
+        "sha256": "ba01780d63b78ff92138d79b7fb08bb13f6574bf893967b2ffaf52d239762c80",
+        "sha256_in_prefix": "ba01780d63b78ff92138d79b7fb08bb13f6574bf893967b2ffaf52d239762c80",
+        "size_in_bytes": 484
+      },
+      {
+        "_path": "share/zoneinfo/America/Glace_Bay",
+        "path_type": "hardlink",
+        "sha256": "235a68b0f1c011f83f2dcfc541d5f507c17cfc0d0d7899caef6a77e8f13ba4a3",
+        "sha256_in_prefix": "235a68b0f1c011f83f2dcfc541d5f507c17cfc0d0d7899caef6a77e8f13ba4a3",
+        "size_in_bytes": 880
+      },
+      {
+        "_path": "share/zoneinfo/America/Godthab",
+        "path_type": "hardlink",
+        "sha256": "2e5199e58fee77d270591be77079d41d102b41b6e735c9a6af3dddb8c851dc77",
+        "sha256_in_prefix": "2e5199e58fee77d270591be77079d41d102b41b6e735c9a6af3dddb8c851dc77",
+        "size_in_bytes": 965
+      },
+      {
+        "_path": "share/zoneinfo/America/Goose_Bay",
+        "path_type": "hardlink",
+        "sha256": "802240d52936722520d962279fc0e63c1c11030d058d06d83da5092bcd26b4c2",
+        "sha256_in_prefix": "802240d52936722520d962279fc0e63c1c11030d058d06d83da5092bcd26b4c2",
+        "size_in_bytes": 1580
+      },
+      {
+        "_path": "share/zoneinfo/America/Grand_Turk",
+        "path_type": "hardlink",
+        "sha256": "1a9f21a4cb7d3f74281079ac217d9ba8634c9144af97066aa8dcdc711f9c6def",
+        "sha256_in_prefix": "1a9f21a4cb7d3f74281079ac217d9ba8634c9144af97066aa8dcdc711f9c6def",
+        "size_in_bytes": 853
+      },
+      {
+        "_path": "share/zoneinfo/America/Grenada",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Guadeloupe",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Guatemala",
+        "path_type": "hardlink",
+        "sha256": "0463c623897237a20517f4f4931d6ada587753948485bc83a8b16e5bc10509a5",
+        "sha256_in_prefix": "0463c623897237a20517f4f4931d6ada587753948485bc83a8b16e5bc10509a5",
+        "size_in_bytes": 212
+      },
+      {
+        "_path": "share/zoneinfo/America/Guayaquil",
+        "path_type": "hardlink",
+        "sha256": "f0e21a0b2f928ab28acf823bee5e8c4050e048b1ed8cdd13be494b54467fd34f",
+        "sha256_in_prefix": "f0e21a0b2f928ab28acf823bee5e8c4050e048b1ed8cdd13be494b54467fd34f",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "share/zoneinfo/America/Guyana",
+        "path_type": "hardlink",
+        "sha256": "3e69c4b56b4e4da9ac3c95c4a3b3dc3500b2d91a7e7af1b2261e1c7f4a63011e",
+        "sha256_in_prefix": "3e69c4b56b4e4da9ac3c95c4a3b3dc3500b2d91a7e7af1b2261e1c7f4a63011e",
+        "size_in_bytes": 181
+      },
+      {
+        "_path": "share/zoneinfo/America/Halifax",
+        "path_type": "hardlink",
+        "sha256": "90ee5a841336a132df592e0a5f5e456ca5dfa39c20f9ff6fc35fe130e2121a28",
+        "sha256_in_prefix": "90ee5a841336a132df592e0a5f5e456ca5dfa39c20f9ff6fc35fe130e2121a28",
+        "size_in_bytes": 1672
+      },
+      {
+        "_path": "share/zoneinfo/America/Havana",
+        "path_type": "hardlink",
+        "sha256": "9ace6b0aeab6c81338f55993ca632d15037773968137596477c8e3cca767366f",
+        "sha256_in_prefix": "9ace6b0aeab6c81338f55993ca632d15037773968137596477c8e3cca767366f",
+        "size_in_bytes": 1117
+      },
+      {
+        "_path": "share/zoneinfo/America/Hermosillo",
+        "path_type": "hardlink",
+        "sha256": "52bd4c612017dd06d3d945f9ecb983f37a3ab3667ee986d878eb9f2af4fecd33",
+        "sha256_in_prefix": "52bd4c612017dd06d3d945f9ecb983f37a3ab3667ee986d878eb9f2af4fecd33",
+        "size_in_bytes": 258
+      },
+      {
+        "_path": "share/zoneinfo/America/Indiana/Indianapolis",
+        "path_type": "hardlink",
+        "sha256": "e678f42a13efbd7be0f26a9ce53e04b1c28a582eab05611cb01c16836432f07b",
+        "sha256_in_prefix": "e678f42a13efbd7be0f26a9ce53e04b1c28a582eab05611cb01c16836432f07b",
+        "size_in_bytes": 531
+      },
+      {
+        "_path": "share/zoneinfo/America/Indiana/Knox",
+        "path_type": "hardlink",
+        "sha256": "2890b35dcb7c093308b552d82d8781a8ce9a4fa6f9de058283a6836ec1f9f282",
+        "sha256_in_prefix": "2890b35dcb7c093308b552d82d8781a8ce9a4fa6f9de058283a6836ec1f9f282",
+        "size_in_bytes": 1016
+      },
+      {
+        "_path": "share/zoneinfo/America/Indiana/Marengo",
+        "path_type": "hardlink",
+        "sha256": "ca05a6abcb1879ef0d17095267243fb6c2a8a4540ca7d35ee79ef31866f21766",
+        "sha256_in_prefix": "ca05a6abcb1879ef0d17095267243fb6c2a8a4540ca7d35ee79ef31866f21766",
+        "size_in_bytes": 567
+      },
+      {
+        "_path": "share/zoneinfo/America/Indiana/Petersburg",
+        "path_type": "hardlink",
+        "sha256": "048aee6f31c4a79428c8c68f8186c2d7349afc5dcbc295f328cf311f7ac7b292",
+        "sha256_in_prefix": "048aee6f31c4a79428c8c68f8186c2d7349afc5dcbc295f328cf311f7ac7b292",
+        "size_in_bytes": 683
+      },
+      {
+        "_path": "share/zoneinfo/America/Indiana/Tell_City",
+        "path_type": "hardlink",
+        "sha256": "7a6d983070d61055dd647d012a2e5b2d1010f1b6037e8a764f443c4aa0e1d01f",
+        "sha256_in_prefix": "7a6d983070d61055dd647d012a2e5b2d1010f1b6037e8a764f443c4aa0e1d01f",
+        "size_in_bytes": 522
+      },
+      {
+        "_path": "share/zoneinfo/America/Indiana/Vevay",
+        "path_type": "hardlink",
+        "sha256": "74f937df87bb310c25ef5f9abcdc911016155ae15341c54a7e5b65461ae5469c",
+        "sha256_in_prefix": "74f937df87bb310c25ef5f9abcdc911016155ae15341c54a7e5b65461ae5469c",
+        "size_in_bytes": 369
+      },
+      {
+        "_path": "share/zoneinfo/America/Indiana/Vincennes",
+        "path_type": "hardlink",
+        "sha256": "8e23830d77a998b3f782f0a406e7dd137ae9e5c1177ed0479ca9def3f5ce3828",
+        "sha256_in_prefix": "8e23830d77a998b3f782f0a406e7dd137ae9e5c1177ed0479ca9def3f5ce3828",
+        "size_in_bytes": 558
+      },
+      {
+        "_path": "share/zoneinfo/America/Indiana/Winamac",
+        "path_type": "hardlink",
+        "sha256": "86c12e9da2eb6f1beca72577426e140fbc7ba8e01e06dcdc6dbcc034d32b762c",
+        "sha256_in_prefix": "86c12e9da2eb6f1beca72577426e140fbc7ba8e01e06dcdc6dbcc034d32b762c",
+        "size_in_bytes": 603
+      },
+      {
+        "_path": "share/zoneinfo/America/Indianapolis",
+        "path_type": "hardlink",
+        "sha256": "e678f42a13efbd7be0f26a9ce53e04b1c28a582eab05611cb01c16836432f07b",
+        "sha256_in_prefix": "e678f42a13efbd7be0f26a9ce53e04b1c28a582eab05611cb01c16836432f07b",
+        "size_in_bytes": 531
+      },
+      {
+        "_path": "share/zoneinfo/America/Inuvik",
+        "path_type": "hardlink",
+        "sha256": "77f657f94492ef41c84fefcf44928c63a99b411bdb28bbeccbd6abeee2f6338d",
+        "sha256_in_prefix": "77f657f94492ef41c84fefcf44928c63a99b411bdb28bbeccbd6abeee2f6338d",
+        "size_in_bytes": 817
+      },
+      {
+        "_path": "share/zoneinfo/America/Iqaluit",
+        "path_type": "hardlink",
+        "sha256": "9ce352ef392c1874eb6c4263ef72d84595bdeb83a7710ba3fd5e9f363a43a10d",
+        "sha256_in_prefix": "9ce352ef392c1874eb6c4263ef72d84595bdeb83a7710ba3fd5e9f363a43a10d",
+        "size_in_bytes": 855
+      },
+      {
+        "_path": "share/zoneinfo/America/Jamaica",
+        "path_type": "hardlink",
+        "sha256": "a437b1700333aeff53a8b5868d5387c080dc14c2d3e95aa5ce36f901b3669284",
+        "sha256_in_prefix": "a437b1700333aeff53a8b5868d5387c080dc14c2d3e95aa5ce36f901b3669284",
+        "size_in_bytes": 339
+      },
+      {
+        "_path": "share/zoneinfo/America/Jujuy",
+        "path_type": "hardlink",
+        "sha256": "ed8a6339c99568a2a98aadf5ad07bc4d30cd131747f638d922175c66ff928548",
+        "sha256_in_prefix": "ed8a6339c99568a2a98aadf5ad07bc4d30cd131747f638d922175c66ff928548",
+        "size_in_bytes": 690
+      },
+      {
+        "_path": "share/zoneinfo/America/Juneau",
+        "path_type": "hardlink",
+        "sha256": "57c22a45a247487ee89cad60bb7618b56fdae1590dc23c790c2bd05e915d600a",
+        "sha256_in_prefix": "57c22a45a247487ee89cad60bb7618b56fdae1590dc23c790c2bd05e915d600a",
+        "size_in_bytes": 966
+      },
+      {
+        "_path": "share/zoneinfo/America/Kentucky/Louisville",
+        "path_type": "hardlink",
+        "sha256": "cd2d924b9ef70fd4e6419156b52c9121537765754dff61695416eda9014ccca5",
+        "sha256_in_prefix": "cd2d924b9ef70fd4e6419156b52c9121537765754dff61695416eda9014ccca5",
+        "size_in_bytes": 1242
+      },
+      {
+        "_path": "share/zoneinfo/America/Kentucky/Monticello",
+        "path_type": "hardlink",
+        "sha256": "e78a2bda843d6d26ccf627d1a0e8d5ed48d117cde34923eec5f19e5c7d2722a9",
+        "sha256_in_prefix": "e78a2bda843d6d26ccf627d1a0e8d5ed48d117cde34923eec5f19e5c7d2722a9",
+        "size_in_bytes": 972
+      },
+      {
+        "_path": "share/zoneinfo/America/Knox_IN",
+        "path_type": "hardlink",
+        "sha256": "2890b35dcb7c093308b552d82d8781a8ce9a4fa6f9de058283a6836ec1f9f282",
+        "sha256_in_prefix": "2890b35dcb7c093308b552d82d8781a8ce9a4fa6f9de058283a6836ec1f9f282",
+        "size_in_bytes": 1016
+      },
+      {
+        "_path": "share/zoneinfo/America/Kralendijk",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/La_Paz",
+        "path_type": "hardlink",
+        "sha256": "da2601c677341c8c00ce5c7e437008f4b6f4188f3b558dbbf6819cae8059495b",
+        "sha256_in_prefix": "da2601c677341c8c00ce5c7e437008f4b6f4188f3b558dbbf6819cae8059495b",
+        "size_in_bytes": 170
+      },
+      {
+        "_path": "share/zoneinfo/America/Lima",
+        "path_type": "hardlink",
+        "sha256": "eef363461c732fe5f89326daf8d9335d8340384f9caaa717bf35d3a9c4d70616",
+        "sha256_in_prefix": "eef363461c732fe5f89326daf8d9335d8340384f9caaa717bf35d3a9c4d70616",
+        "size_in_bytes": 283
+      },
+      {
+        "_path": "share/zoneinfo/America/Los_Angeles",
+        "path_type": "hardlink",
+        "sha256": "200d05754f6d83a371cf408d7085125797657b3b0bebeba1e508cffe86a3e5c8",
+        "sha256_in_prefix": "200d05754f6d83a371cf408d7085125797657b3b0bebeba1e508cffe86a3e5c8",
+        "size_in_bytes": 1294
+      },
+      {
+        "_path": "share/zoneinfo/America/Louisville",
+        "path_type": "hardlink",
+        "sha256": "cd2d924b9ef70fd4e6419156b52c9121537765754dff61695416eda9014ccca5",
+        "sha256_in_prefix": "cd2d924b9ef70fd4e6419156b52c9121537765754dff61695416eda9014ccca5",
+        "size_in_bytes": 1242
+      },
+      {
+        "_path": "share/zoneinfo/America/Lower_Princes",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Maceio",
+        "path_type": "hardlink",
+        "sha256": "752560d1d1de753f70d503b617502f5a87a5e3f87cc26b984b882e11a2fee4a9",
+        "sha256_in_prefix": "752560d1d1de753f70d503b617502f5a87a5e3f87cc26b984b882e11a2fee4a9",
+        "size_in_bytes": 502
+      },
+      {
+        "_path": "share/zoneinfo/America/Managua",
+        "path_type": "hardlink",
+        "sha256": "658b28c8dfc6225c00229223d6ca634033d6190f641594a2a6351b3bc71a19fc",
+        "sha256_in_prefix": "658b28c8dfc6225c00229223d6ca634033d6190f641594a2a6351b3bc71a19fc",
+        "size_in_bytes": 295
+      },
+      {
+        "_path": "share/zoneinfo/America/Manaus",
+        "path_type": "hardlink",
+        "sha256": "f6482b869af207de18395a2c8499628a20d27fd9b08dbdce6705f41eeb0d46b9",
+        "sha256_in_prefix": "f6482b869af207de18395a2c8499628a20d27fd9b08dbdce6705f41eeb0d46b9",
+        "size_in_bytes": 412
+      },
+      {
+        "_path": "share/zoneinfo/America/Marigot",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Martinique",
+        "path_type": "hardlink",
+        "sha256": "9b7ac2e8ca2073a71cd5af5727c14f21885969214d758931699fa97c7846dd7e",
+        "sha256_in_prefix": "9b7ac2e8ca2073a71cd5af5727c14f21885969214d758931699fa97c7846dd7e",
+        "size_in_bytes": 178
+      },
+      {
+        "_path": "share/zoneinfo/America/Matamoros",
+        "path_type": "hardlink",
+        "sha256": "2b1800306904ed326eba0f5bc85b13dca37cdfa5f73b25eaefbbfeb45a4b56f7",
+        "sha256_in_prefix": "2b1800306904ed326eba0f5bc85b13dca37cdfa5f73b25eaefbbfeb45a4b56f7",
+        "size_in_bytes": 437
+      },
+      {
+        "_path": "share/zoneinfo/America/Mazatlan",
+        "path_type": "hardlink",
+        "sha256": "20dede710f520eaf6c0cdbeefe773fc6e30dd8b1d28aaf17e9842099551ee9a6",
+        "sha256_in_prefix": "20dede710f520eaf6c0cdbeefe773fc6e30dd8b1d28aaf17e9842099551ee9a6",
+        "size_in_bytes": 690
+      },
+      {
+        "_path": "share/zoneinfo/America/Mendoza",
+        "path_type": "hardlink",
+        "sha256": "74be2ad33818d8528f6c6f1c0be5a49e7a69f2d17663b496816482fc6fd6ce72",
+        "sha256_in_prefix": "74be2ad33818d8528f6c6f1c0be5a49e7a69f2d17663b496816482fc6fd6ce72",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Menominee",
+        "path_type": "hardlink",
+        "sha256": "a149899b3399b42858ac1f489fe1351aa1158b6a202a33c4497954c92506b3de",
+        "sha256_in_prefix": "a149899b3399b42858ac1f489fe1351aa1158b6a202a33c4497954c92506b3de",
+        "size_in_bytes": 917
+      },
+      {
+        "_path": "share/zoneinfo/America/Merida",
+        "path_type": "hardlink",
+        "sha256": "2c1a4e12fe31c5470be41ef015235add4c84efadbe1224976f528f40d2b0c025",
+        "sha256_in_prefix": "2c1a4e12fe31c5470be41ef015235add4c84efadbe1224976f528f40d2b0c025",
+        "size_in_bytes": 654
+      },
+      {
+        "_path": "share/zoneinfo/America/Metlakatla",
+        "path_type": "hardlink",
+        "sha256": "1158f52e430282bcba993f0b9ff1691f1a49494d284a771f6c7196210d1223fd",
+        "sha256_in_prefix": "1158f52e430282bcba993f0b9ff1691f1a49494d284a771f6c7196210d1223fd",
+        "size_in_bytes": 586
+      },
+      {
+        "_path": "share/zoneinfo/America/Mexico_City",
+        "path_type": "hardlink",
+        "sha256": "37dd2bf08f13fce0f707c3b1f4cec4018efbd9c47c8367b0fb4debbd461bd72f",
+        "sha256_in_prefix": "37dd2bf08f13fce0f707c3b1f4cec4018efbd9c47c8367b0fb4debbd461bd72f",
+        "size_in_bytes": 773
+      },
+      {
+        "_path": "share/zoneinfo/America/Miquelon",
+        "path_type": "hardlink",
+        "sha256": "11ecbe21de5be0714e0c837079116d6c38dc823b3f9b2882d94c2c818b789159",
+        "sha256_in_prefix": "11ecbe21de5be0714e0c837079116d6c38dc823b3f9b2882d94c2c818b789159",
+        "size_in_bytes": 550
+      },
+      {
+        "_path": "share/zoneinfo/America/Moncton",
+        "path_type": "hardlink",
+        "sha256": "927ac13431701c0185af49d6253050fb5d05fdf679c789f74a766d1fe288ea1f",
+        "sha256_in_prefix": "927ac13431701c0185af49d6253050fb5d05fdf679c789f74a766d1fe288ea1f",
+        "size_in_bytes": 1493
+      },
+      {
+        "_path": "share/zoneinfo/America/Monterrey",
+        "path_type": "hardlink",
+        "sha256": "d5a62c229f8d6b494300a56b716e3054a1405f2e4102a0c6db058b4fdc139a64",
+        "sha256_in_prefix": "d5a62c229f8d6b494300a56b716e3054a1405f2e4102a0c6db058b4fdc139a64",
+        "size_in_bytes": 709
+      },
+      {
+        "_path": "share/zoneinfo/America/Montevideo",
+        "path_type": "hardlink",
+        "sha256": "97b1635baaac706cddbdf8e56c8799e4243f005592dd97950d2e69a4c24234cd",
+        "sha256_in_prefix": "97b1635baaac706cddbdf8e56c8799e4243f005592dd97950d2e69a4c24234cd",
+        "size_in_bytes": 969
+      },
+      {
+        "_path": "share/zoneinfo/America/Montreal",
+        "path_type": "hardlink",
+        "sha256": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "sha256_in_prefix": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "size_in_bytes": 1717
+      },
+      {
+        "_path": "share/zoneinfo/America/Montserrat",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Nassau",
+        "path_type": "hardlink",
+        "sha256": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "sha256_in_prefix": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "size_in_bytes": 1717
+      },
+      {
+        "_path": "share/zoneinfo/America/New_York",
+        "path_type": "hardlink",
+        "sha256": "d7f2206b3a45989fc9ad63d558922532fa7352280d5f87176bf1db79cb1d1fa9",
+        "sha256_in_prefix": "d7f2206b3a45989fc9ad63d558922532fa7352280d5f87176bf1db79cb1d1fa9",
+        "size_in_bytes": 1744
+      },
+      {
+        "_path": "share/zoneinfo/America/Nipigon",
+        "path_type": "hardlink",
+        "sha256": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "sha256_in_prefix": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "size_in_bytes": 1717
+      },
+      {
+        "_path": "share/zoneinfo/America/Nome",
+        "path_type": "hardlink",
+        "sha256": "ffe8a77109e1d03c0af6126a15a6333b8a2c50a01407693695a7b9eb9b1b9690",
+        "sha256_in_prefix": "ffe8a77109e1d03c0af6126a15a6333b8a2c50a01407693695a7b9eb9b1b9690",
+        "size_in_bytes": 975
+      },
+      {
+        "_path": "share/zoneinfo/America/Noronha",
+        "path_type": "hardlink",
+        "sha256": "434af71ad039cb644690e8f9e8e4d91b9b6e072d41ea47db872ac9a8281fdbb8",
+        "sha256_in_prefix": "434af71ad039cb644690e8f9e8e4d91b9b6e072d41ea47db872ac9a8281fdbb8",
+        "size_in_bytes": 484
+      },
+      {
+        "_path": "share/zoneinfo/America/North_Dakota/Beulah",
+        "path_type": "hardlink",
+        "sha256": "46f681212eb46cd351991122e815d25846c94ab70fec9f0d9b183c3a405cae8c",
+        "sha256_in_prefix": "46f681212eb46cd351991122e815d25846c94ab70fec9f0d9b183c3a405cae8c",
+        "size_in_bytes": 1043
+      },
+      {
+        "_path": "share/zoneinfo/America/North_Dakota/Center",
+        "path_type": "hardlink",
+        "sha256": "334f71e0cc7a85c040c24b6fc2fd7a62f3d19acb838d9103c074f452691c832a",
+        "sha256_in_prefix": "334f71e0cc7a85c040c24b6fc2fd7a62f3d19acb838d9103c074f452691c832a",
+        "size_in_bytes": 990
+      },
+      {
+        "_path": "share/zoneinfo/America/North_Dakota/New_Salem",
+        "path_type": "hardlink",
+        "sha256": "99971af60c9f3b6512cdac7bbf498b24460128156622aca55aa9df2e04ac572b",
+        "sha256_in_prefix": "99971af60c9f3b6512cdac7bbf498b24460128156622aca55aa9df2e04ac572b",
+        "size_in_bytes": 990
+      },
+      {
+        "_path": "share/zoneinfo/America/Nuuk",
+        "path_type": "hardlink",
+        "sha256": "2e5199e58fee77d270591be77079d41d102b41b6e735c9a6af3dddb8c851dc77",
+        "sha256_in_prefix": "2e5199e58fee77d270591be77079d41d102b41b6e735c9a6af3dddb8c851dc77",
+        "size_in_bytes": 965
+      },
+      {
+        "_path": "share/zoneinfo/America/Ojinaga",
+        "path_type": "hardlink",
+        "sha256": "f7b989f5523c875951011108749753cff3022edc21e1bdfa89a43d4289444e90",
+        "sha256_in_prefix": "f7b989f5523c875951011108749753cff3022edc21e1bdfa89a43d4289444e90",
+        "size_in_bytes": 718
+      },
+      {
+        "_path": "share/zoneinfo/America/Panama",
+        "path_type": "hardlink",
+        "sha256": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "sha256_in_prefix": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "share/zoneinfo/America/Pangnirtung",
+        "path_type": "hardlink",
+        "sha256": "9ce352ef392c1874eb6c4263ef72d84595bdeb83a7710ba3fd5e9f363a43a10d",
+        "sha256_in_prefix": "9ce352ef392c1874eb6c4263ef72d84595bdeb83a7710ba3fd5e9f363a43a10d",
+        "size_in_bytes": 855
+      },
+      {
+        "_path": "share/zoneinfo/America/Paramaribo",
+        "path_type": "hardlink",
+        "sha256": "0b6bfdb51ea7a39e024440960c5840353978d14b00e00847b1d9c6a0d09be3f4",
+        "sha256_in_prefix": "0b6bfdb51ea7a39e024440960c5840353978d14b00e00847b1d9c6a0d09be3f4",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "share/zoneinfo/America/Phoenix",
+        "path_type": "hardlink",
+        "sha256": "ae11453c21d08984de75f2efec04dc93178a7b4e23c5e52f2098b8bd45ccb547",
+        "sha256_in_prefix": "ae11453c21d08984de75f2efec04dc93178a7b4e23c5e52f2098b8bd45ccb547",
+        "size_in_bytes": 240
+      },
+      {
+        "_path": "share/zoneinfo/America/Port-au-Prince",
+        "path_type": "hardlink",
+        "sha256": "c2c4ba55b43ffdb289d8850c3f2fcf6a8d022d12b9a57101aea91a62eaacdcdb",
+        "sha256_in_prefix": "c2c4ba55b43ffdb289d8850c3f2fcf6a8d022d12b9a57101aea91a62eaacdcdb",
+        "size_in_bytes": 565
+      },
+      {
+        "_path": "share/zoneinfo/America/Port_of_Spain",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Porto_Acre",
+        "path_type": "hardlink",
+        "sha256": "563b9052bebaf2986ae5b707e34afde013e7641287cc97ff31005f33a0dbf7a5",
+        "sha256_in_prefix": "563b9052bebaf2986ae5b707e34afde013e7641287cc97ff31005f33a0dbf7a5",
+        "size_in_bytes": 418
+      },
+      {
+        "_path": "share/zoneinfo/America/Porto_Velho",
+        "path_type": "hardlink",
+        "sha256": "f723d4f045ed2834072c5ef8e444dcf6a659f4c7b608aea3be06fa4b9de948a8",
+        "sha256_in_prefix": "f723d4f045ed2834072c5ef8e444dcf6a659f4c7b608aea3be06fa4b9de948a8",
+        "size_in_bytes": 394
+      },
+      {
+        "_path": "share/zoneinfo/America/Puerto_Rico",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Punta_Arenas",
+        "path_type": "hardlink",
+        "sha256": "d80aa1edbaa8fa64259cc8d444390239e11899e5e193328fecec4502f8538e30",
+        "sha256_in_prefix": "d80aa1edbaa8fa64259cc8d444390239e11899e5e193328fecec4502f8538e30",
+        "size_in_bytes": 1218
+      },
+      {
+        "_path": "share/zoneinfo/America/Rainy_River",
+        "path_type": "hardlink",
+        "sha256": "00dcf0606054d4f927416e0b47e1fdda2e5ce036fde4b53e51084f8566428c3a",
+        "sha256_in_prefix": "00dcf0606054d4f927416e0b47e1fdda2e5ce036fde4b53e51084f8566428c3a",
+        "size_in_bytes": 1294
+      },
+      {
+        "_path": "share/zoneinfo/America/Rankin_Inlet",
+        "path_type": "hardlink",
+        "sha256": "25009740177273cb894e32053b88d9bb34b43a31b48111eff0c3e677337ddc25",
+        "sha256_in_prefix": "25009740177273cb894e32053b88d9bb34b43a31b48111eff0c3e677337ddc25",
+        "size_in_bytes": 807
+      },
+      {
+        "_path": "share/zoneinfo/America/Recife",
+        "path_type": "hardlink",
+        "sha256": "df2653c05dcc265918d03e3c090513cc24700c27c636af045d74d96250605138",
+        "sha256_in_prefix": "df2653c05dcc265918d03e3c090513cc24700c27c636af045d74d96250605138",
+        "size_in_bytes": 484
+      },
+      {
+        "_path": "share/zoneinfo/America/Regina",
+        "path_type": "hardlink",
+        "sha256": "fc91ee9ecdb6e6213e4c773d345a7e441ab83d650b02e1b0d8e2dba4e07f50cc",
+        "sha256_in_prefix": "fc91ee9ecdb6e6213e4c773d345a7e441ab83d650b02e1b0d8e2dba4e07f50cc",
+        "size_in_bytes": 638
+      },
+      {
+        "_path": "share/zoneinfo/America/Resolute",
+        "path_type": "hardlink",
+        "sha256": "d94789051d994a49f56d4672d06d1212106d63dbf27304915389da2beb30d38e",
+        "sha256_in_prefix": "d94789051d994a49f56d4672d06d1212106d63dbf27304915389da2beb30d38e",
+        "size_in_bytes": 807
+      },
+      {
+        "_path": "share/zoneinfo/America/Rio_Branco",
+        "path_type": "hardlink",
+        "sha256": "563b9052bebaf2986ae5b707e34afde013e7641287cc97ff31005f33a0dbf7a5",
+        "sha256_in_prefix": "563b9052bebaf2986ae5b707e34afde013e7641287cc97ff31005f33a0dbf7a5",
+        "size_in_bytes": 418
+      },
+      {
+        "_path": "share/zoneinfo/America/Rosario",
+        "path_type": "hardlink",
+        "sha256": "f488f75a34fd99630a438dcb792508a90b836fdcd2dc54a51d83d535025315fd",
+        "sha256_in_prefix": "f488f75a34fd99630a438dcb792508a90b836fdcd2dc54a51d83d535025315fd",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/America/Santa_Isabel",
+        "path_type": "hardlink",
+        "sha256": "3065abfbab680d16ab8cc5d36a23885a004558d6f0ee51ef89d2ee3ca1717c8a",
+        "sha256_in_prefix": "3065abfbab680d16ab8cc5d36a23885a004558d6f0ee51ef89d2ee3ca1717c8a",
+        "size_in_bytes": 1079
+      },
+      {
+        "_path": "share/zoneinfo/America/Santarem",
+        "path_type": "hardlink",
+        "sha256": "743106b27ae6e30af3978b0ae8af0fcc4ae804a0fb03557b1c16bc7165b870c9",
+        "sha256_in_prefix": "743106b27ae6e30af3978b0ae8af0fcc4ae804a0fb03557b1c16bc7165b870c9",
+        "size_in_bytes": 409
+      },
+      {
+        "_path": "share/zoneinfo/America/Santiago",
+        "path_type": "hardlink",
+        "sha256": "fd006953c2b442a2e1e66db2a967dd932a4824390f01cddd9c801ce63450c715",
+        "sha256_in_prefix": "fd006953c2b442a2e1e66db2a967dd932a4824390f01cddd9c801ce63450c715",
+        "size_in_bytes": 1354
+      },
+      {
+        "_path": "share/zoneinfo/America/Santo_Domingo",
+        "path_type": "hardlink",
+        "sha256": "c66268e7d9995cded69dffb7263977ee6082fbc19f37ac6693697fbe78327de2",
+        "sha256_in_prefix": "c66268e7d9995cded69dffb7263977ee6082fbc19f37ac6693697fbe78327de2",
+        "size_in_bytes": 317
+      },
+      {
+        "_path": "share/zoneinfo/America/Sao_Paulo",
+        "path_type": "hardlink",
+        "sha256": "fa2ceb222f065c0289f3997ff0c54ba05a74a599b4522870fa86a96e24e18891",
+        "sha256_in_prefix": "fa2ceb222f065c0289f3997ff0c54ba05a74a599b4522870fa86a96e24e18891",
+        "size_in_bytes": 952
+      },
+      {
+        "_path": "share/zoneinfo/America/Scoresbysund",
+        "path_type": "hardlink",
+        "sha256": "c2b848115005236f6a293dd374e5a2889c08f34028857c307dbd6608f4805c7a",
+        "sha256_in_prefix": "c2b848115005236f6a293dd374e5a2889c08f34028857c307dbd6608f4805c7a",
+        "size_in_bytes": 984
+      },
+      {
+        "_path": "share/zoneinfo/America/Shiprock",
+        "path_type": "hardlink",
+        "sha256": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "sha256_in_prefix": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "size_in_bytes": 1042
+      },
+      {
+        "_path": "share/zoneinfo/America/Sitka",
+        "path_type": "hardlink",
+        "sha256": "a45e72967fbe30ecc430369c35dfc87741d7f6902681ef0f39f731c93361d7ed",
+        "sha256_in_prefix": "a45e72967fbe30ecc430369c35dfc87741d7f6902681ef0f39f731c93361d7ed",
+        "size_in_bytes": 956
+      },
+      {
+        "_path": "share/zoneinfo/America/St_Barthelemy",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/St_Johns",
+        "path_type": "hardlink",
+        "sha256": "bfdf6afc014c3e597930cc4ca7df1aa98e347268acdb07224df4eab36fe46f49",
+        "sha256_in_prefix": "bfdf6afc014c3e597930cc4ca7df1aa98e347268acdb07224df4eab36fe46f49",
+        "size_in_bytes": 1878
+      },
+      {
+        "_path": "share/zoneinfo/America/St_Kitts",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/St_Lucia",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/St_Thomas",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/St_Vincent",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Swift_Current",
+        "path_type": "hardlink",
+        "sha256": "17e6fae5869ac76dc2b2e85299e4c397a4eff5dbb822cbd6bcc6db4aec0790b3",
+        "sha256_in_prefix": "17e6fae5869ac76dc2b2e85299e4c397a4eff5dbb822cbd6bcc6db4aec0790b3",
+        "size_in_bytes": 368
+      },
+      {
+        "_path": "share/zoneinfo/America/Tegucigalpa",
+        "path_type": "hardlink",
+        "sha256": "2a5bea0491acc1af43217944dda714fa981de0816a0de051ad4cf4d8f9a5342d",
+        "sha256_in_prefix": "2a5bea0491acc1af43217944dda714fa981de0816a0de051ad4cf4d8f9a5342d",
+        "size_in_bytes": 194
+      },
+      {
+        "_path": "share/zoneinfo/America/Thule",
+        "path_type": "hardlink",
+        "sha256": "2f32f98dd9999314641dd0375e4a2a24f1bf2269659d24616182d0a4c7ff4d8f",
+        "sha256_in_prefix": "2f32f98dd9999314641dd0375e4a2a24f1bf2269659d24616182d0a4c7ff4d8f",
+        "size_in_bytes": 455
+      },
+      {
+        "_path": "share/zoneinfo/America/Thunder_Bay",
+        "path_type": "hardlink",
+        "sha256": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "sha256_in_prefix": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "size_in_bytes": 1717
+      },
+      {
+        "_path": "share/zoneinfo/America/Tijuana",
+        "path_type": "hardlink",
+        "sha256": "3065abfbab680d16ab8cc5d36a23885a004558d6f0ee51ef89d2ee3ca1717c8a",
+        "sha256_in_prefix": "3065abfbab680d16ab8cc5d36a23885a004558d6f0ee51ef89d2ee3ca1717c8a",
+        "size_in_bytes": 1079
+      },
+      {
+        "_path": "share/zoneinfo/America/Toronto",
+        "path_type": "hardlink",
+        "sha256": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "sha256_in_prefix": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "size_in_bytes": 1717
+      },
+      {
+        "_path": "share/zoneinfo/America/Tortola",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Vancouver",
+        "path_type": "hardlink",
+        "sha256": "129a2eef5b147dfbc7075addef04f492bbe8de8917015e39fd359c385a72dba4",
+        "sha256_in_prefix": "129a2eef5b147dfbc7075addef04f492bbe8de8917015e39fd359c385a72dba4",
+        "size_in_bytes": 1330
+      },
+      {
+        "_path": "share/zoneinfo/America/Virgin",
+        "path_type": "hardlink",
+        "sha256": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "sha256_in_prefix": "abbe8628dd5487c889db816ce3a5077bbb47f6bafafeb9411d92d6ef2f70ce8d",
+        "size_in_bytes": 177
+      },
+      {
+        "_path": "share/zoneinfo/America/Whitehorse",
+        "path_type": "hardlink",
+        "sha256": "0b26388cd7747f335275fd4795819f6a4b40a661fbd6d44d465a4e10edf60c6b",
+        "sha256_in_prefix": "0b26388cd7747f335275fd4795819f6a4b40a661fbd6d44d465a4e10edf60c6b",
+        "size_in_bytes": 1029
+      },
+      {
+        "_path": "share/zoneinfo/America/Winnipeg",
+        "path_type": "hardlink",
+        "sha256": "00dcf0606054d4f927416e0b47e1fdda2e5ce036fde4b53e51084f8566428c3a",
+        "sha256_in_prefix": "00dcf0606054d4f927416e0b47e1fdda2e5ce036fde4b53e51084f8566428c3a",
+        "size_in_bytes": 1294
+      },
+      {
+        "_path": "share/zoneinfo/America/Yakutat",
+        "path_type": "hardlink",
+        "sha256": "a6f1cb54d035988f87f5f0439e59e923a07d5f354541ecaf23d9f22246853584",
+        "sha256_in_prefix": "a6f1cb54d035988f87f5f0439e59e923a07d5f354541ecaf23d9f22246853584",
+        "size_in_bytes": 946
+      },
+      {
+        "_path": "share/zoneinfo/America/Yellowknife",
+        "path_type": "hardlink",
+        "sha256": "0eada6c5c48d59984c591ab1c30b4c71aab000818cc243b3cfe996f1f26c715f",
+        "sha256_in_prefix": "0eada6c5c48d59984c591ab1c30b4c71aab000818cc243b3cfe996f1f26c715f",
+        "size_in_bytes": 970
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/Casey",
+        "path_type": "hardlink",
+        "sha256": "d6373e1408ef90a9e60a3873f3ec908042ab37fb159b3022f03568cbdfcaf004",
+        "sha256_in_prefix": "d6373e1408ef90a9e60a3873f3ec908042ab37fb159b3022f03568cbdfcaf004",
+        "size_in_bytes": 287
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/Davis",
+        "path_type": "hardlink",
+        "sha256": "3e89bfdbaeebb28665eb22ef62596efd25b5922c48ad23e6b1df872f3b67df76",
+        "sha256_in_prefix": "3e89bfdbaeebb28665eb22ef62596efd25b5922c48ad23e6b1df872f3b67df76",
+        "size_in_bytes": 197
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/DumontDUrville",
+        "path_type": "hardlink",
+        "sha256": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "sha256_in_prefix": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/Macquarie",
+        "path_type": "hardlink",
+        "sha256": "68e66523321d4f07af6935e84240e57b1d8b4850eb83ae06bd17dc2e77c20c03",
+        "sha256_in_prefix": "68e66523321d4f07af6935e84240e57b1d8b4850eb83ae06bd17dc2e77c20c03",
+        "size_in_bytes": 976
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/Mawson",
+        "path_type": "hardlink",
+        "sha256": "518ba2052134a99fb69240406ba5eae60f4d5e0f96fd1d0ffab976b653b48c77",
+        "sha256_in_prefix": "518ba2052134a99fb69240406ba5eae60f4d5e0f96fd1d0ffab976b653b48c77",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/McMurdo",
+        "path_type": "hardlink",
+        "sha256": "0e06e7e55aedbc92ef5b3d106e7c392ab1628cfd8a428b20e92e99028a0bfbb9",
+        "sha256_in_prefix": "0e06e7e55aedbc92ef5b3d106e7c392ab1628cfd8a428b20e92e99028a0bfbb9",
+        "size_in_bytes": 1043
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/Palmer",
+        "path_type": "hardlink",
+        "sha256": "dcc5df85005a441e7bfe3a8764c97e33f2b8f0d3057b8cc02dceef68cc92e71c",
+        "sha256_in_prefix": "dcc5df85005a441e7bfe3a8764c97e33f2b8f0d3057b8cc02dceef68cc92e71c",
+        "size_in_bytes": 887
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/Rothera",
+        "path_type": "hardlink",
+        "sha256": "5de75d44bd984c37c45b3408ee70ea7d6f937e0fb911e6f1b07b0c1f2cc6b9d2",
+        "sha256_in_prefix": "5de75d44bd984c37c45b3408ee70ea7d6f937e0fb911e6f1b07b0c1f2cc6b9d2",
+        "size_in_bytes": 132
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/South_Pole",
+        "path_type": "hardlink",
+        "sha256": "0e06e7e55aedbc92ef5b3d106e7c392ab1628cfd8a428b20e92e99028a0bfbb9",
+        "sha256_in_prefix": "0e06e7e55aedbc92ef5b3d106e7c392ab1628cfd8a428b20e92e99028a0bfbb9",
+        "size_in_bytes": 1043
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/Syowa",
+        "path_type": "hardlink",
+        "sha256": "46853e94276af2eea8e86c2f152a871c092df195dc51273b8fc7091faa4b461c",
+        "sha256_in_prefix": "46853e94276af2eea8e86c2f152a871c092df195dc51273b8fc7091faa4b461c",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/Troll",
+        "path_type": "hardlink",
+        "sha256": "b38cf417fb8acf1ddb88a8c4cef1f06f9eb5df65d1b3a211db67c2420956e462",
+        "sha256_in_prefix": "b38cf417fb8acf1ddb88a8c4cef1f06f9eb5df65d1b3a211db67c2420956e462",
+        "size_in_bytes": 158
+      },
+      {
+        "_path": "share/zoneinfo/Antarctica/Vostok",
+        "path_type": "hardlink",
+        "sha256": "703a7e078c0a5c4f14e5bff3a89225c5d198f802003024c93991b76d164128d7",
+        "sha256_in_prefix": "703a7e078c0a5c4f14e5bff3a89225c5d198f802003024c93991b76d164128d7",
+        "size_in_bytes": 170
+      },
+      {
+        "_path": "share/zoneinfo/Arctic/Longyearbyen",
+        "path_type": "hardlink",
+        "sha256": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "sha256_in_prefix": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "size_in_bytes": 705
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Aden",
+        "path_type": "hardlink",
+        "sha256": "46853e94276af2eea8e86c2f152a871c092df195dc51273b8fc7091faa4b461c",
+        "sha256_in_prefix": "46853e94276af2eea8e86c2f152a871c092df195dc51273b8fc7091faa4b461c",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Almaty",
+        "path_type": "hardlink",
+        "sha256": "f3b58d30a085ed6d95eadab92ef5f90d75a88bd32ec230806377fd760c2e8b8b",
+        "sha256_in_prefix": "f3b58d30a085ed6d95eadab92ef5f90d75a88bd32ec230806377fd760c2e8b8b",
+        "size_in_bytes": 618
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Amman",
+        "path_type": "hardlink",
+        "sha256": "28e9ca3b8ff55d1950bcb1bad464db7ca2264ad8700473129f35751315bc8b94",
+        "sha256_in_prefix": "28e9ca3b8ff55d1950bcb1bad464db7ca2264ad8700473129f35751315bc8b94",
+        "size_in_bytes": 928
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Anadyr",
+        "path_type": "hardlink",
+        "sha256": "df46dd66eae0e10fff942a47e74f5313453ba4e70463aab18efb8f17d6a2e727",
+        "sha256_in_prefix": "df46dd66eae0e10fff942a47e74f5313453ba4e70463aab18efb8f17d6a2e727",
+        "size_in_bytes": 743
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Aqtau",
+        "path_type": "hardlink",
+        "sha256": "6d18f6eef1b91ef19e80583978828d9aaddd7ed7989abeca993b382453beed23",
+        "sha256_in_prefix": "6d18f6eef1b91ef19e80583978828d9aaddd7ed7989abeca993b382453beed23",
+        "size_in_bytes": 606
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Aqtobe",
+        "path_type": "hardlink",
+        "sha256": "3e6ef22397267f3c7c0865d1da64090e3b47d76282a71f1ecc529c862255549e",
+        "sha256_in_prefix": "3e6ef22397267f3c7c0865d1da64090e3b47d76282a71f1ecc529c862255549e",
+        "size_in_bytes": 615
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Ashgabat",
+        "path_type": "hardlink",
+        "sha256": "3932c7750f2314f0efc6efc8c0a5ff7375b78dd37a7bb146a0248411bd172aec",
+        "sha256_in_prefix": "3932c7750f2314f0efc6efc8c0a5ff7375b78dd37a7bb146a0248411bd172aec",
+        "size_in_bytes": 375
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Ashkhabad",
+        "path_type": "hardlink",
+        "sha256": "3932c7750f2314f0efc6efc8c0a5ff7375b78dd37a7bb146a0248411bd172aec",
+        "sha256_in_prefix": "3932c7750f2314f0efc6efc8c0a5ff7375b78dd37a7bb146a0248411bd172aec",
+        "size_in_bytes": 375
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Atyrau",
+        "path_type": "hardlink",
+        "sha256": "d581b84332f13d16507861e23ab6e6d1c46cf04453360d4d17d7561305b63e2d",
+        "sha256_in_prefix": "d581b84332f13d16507861e23ab6e6d1c46cf04453360d4d17d7561305b63e2d",
+        "size_in_bytes": 616
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Baghdad",
+        "path_type": "hardlink",
+        "sha256": "cc57ba2d749fba82631ac9984cc1a326d05c00c2e2285903ee3efe55aa8ac07f",
+        "sha256_in_prefix": "cc57ba2d749fba82631ac9984cc1a326d05c00c2e2285903ee3efe55aa8ac07f",
+        "size_in_bytes": 630
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Bahrain",
+        "path_type": "hardlink",
+        "sha256": "6160d6575a371c75b19e6c25cf03160b9dc2f386583e42bf8189fdf8fd17c785",
+        "sha256_in_prefix": "6160d6575a371c75b19e6c25cf03160b9dc2f386583e42bf8189fdf8fd17c785",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Baku",
+        "path_type": "hardlink",
+        "sha256": "fd687a38d6916ad31cf65a7018eeb307da53137f0d678a16838ffeb19975ee60",
+        "sha256_in_prefix": "fd687a38d6916ad31cf65a7018eeb307da53137f0d678a16838ffeb19975ee60",
+        "size_in_bytes": 744
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Bangkok",
+        "path_type": "hardlink",
+        "sha256": "cdc8e2c282d8bc9a5e9c3caf2fc45ff4e9e5cd18f5dec8cb873340ad7c584d64",
+        "sha256_in_prefix": "cdc8e2c282d8bc9a5e9c3caf2fc45ff4e9e5cd18f5dec8cb873340ad7c584d64",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Barnaul",
+        "path_type": "hardlink",
+        "sha256": "506158258bed818552f13aacaaf8faa743900a6377cdd63dc084d683c3831be9",
+        "sha256_in_prefix": "506158258bed818552f13aacaaf8faa743900a6377cdd63dc084d683c3831be9",
+        "size_in_bytes": 753
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Beirut",
+        "path_type": "hardlink",
+        "sha256": "16033882a6d6169e8ab949d59fe1fc5085d9813c9d05e3b10dd6de6c9d06a547",
+        "sha256_in_prefix": "16033882a6d6169e8ab949d59fe1fc5085d9813c9d05e3b10dd6de6c9d06a547",
+        "size_in_bytes": 732
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Bishkek",
+        "path_type": "hardlink",
+        "sha256": "4577715716a2139cf15f96ad425fbb65eb04799563b025c1199e9c25b554f691",
+        "sha256_in_prefix": "4577715716a2139cf15f96ad425fbb65eb04799563b025c1199e9c25b554f691",
+        "size_in_bytes": 618
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Brunei",
+        "path_type": "hardlink",
+        "sha256": "dda8e0208df167e59cf9da9745348cc3ca904434a35e5481231c84fec0d11939",
+        "sha256_in_prefix": "dda8e0208df167e59cf9da9745348cc3ca904434a35e5481231c84fec0d11939",
+        "size_in_bytes": 320
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Calcutta",
+        "path_type": "hardlink",
+        "sha256": "3a00bdbe1bc4959e727567c730ba51b03455ecd455f7c190c5ad14386eb79b0d",
+        "sha256_in_prefix": "3a00bdbe1bc4959e727567c730ba51b03455ecd455f7c190c5ad14386eb79b0d",
+        "size_in_bytes": 220
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Chita",
+        "path_type": "hardlink",
+        "sha256": "d4b99eddc70ee3b4798264dee550aad4149bd26ff5a295a26eadb5cef6659ed8",
+        "sha256_in_prefix": "d4b99eddc70ee3b4798264dee550aad4149bd26ff5a295a26eadb5cef6659ed8",
+        "size_in_bytes": 750
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Choibalsan",
+        "path_type": "hardlink",
+        "sha256": "fbe23c3fafdee01b5121edf009290fb701cebbf93dacfb30f8aa90287242f6f3",
+        "sha256_in_prefix": "fbe23c3fafdee01b5121edf009290fb701cebbf93dacfb30f8aa90287242f6f3",
+        "size_in_bytes": 594
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Chongqing",
+        "path_type": "hardlink",
+        "sha256": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "sha256_in_prefix": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "size_in_bytes": 393
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Chungking",
+        "path_type": "hardlink",
+        "sha256": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "sha256_in_prefix": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "size_in_bytes": 393
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Colombo",
+        "path_type": "hardlink",
+        "sha256": "400ca32bb82d5d459f2ee8eed4cd07dff7b0ea24ccf9bc1fccee686e0bda1f2f",
+        "sha256_in_prefix": "400ca32bb82d5d459f2ee8eed4cd07dff7b0ea24ccf9bc1fccee686e0bda1f2f",
+        "size_in_bytes": 247
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Dacca",
+        "path_type": "hardlink",
+        "sha256": "ac21a61306d6e2a91453641f4e3e732ebc9d542abc1d35a5d5db2a10340ebefa",
+        "sha256_in_prefix": "ac21a61306d6e2a91453641f4e3e732ebc9d542abc1d35a5d5db2a10340ebefa",
+        "size_in_bytes": 231
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Damascus",
+        "path_type": "hardlink",
+        "sha256": "02d6530d1cc7101ed09cac455efb56b0d508d5c0827b6eec01fa437d07743306",
+        "sha256_in_prefix": "02d6530d1cc7101ed09cac455efb56b0d508d5c0827b6eec01fa437d07743306",
+        "size_in_bytes": 1234
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Dhaka",
+        "path_type": "hardlink",
+        "sha256": "ac21a61306d6e2a91453641f4e3e732ebc9d542abc1d35a5d5db2a10340ebefa",
+        "sha256_in_prefix": "ac21a61306d6e2a91453641f4e3e732ebc9d542abc1d35a5d5db2a10340ebefa",
+        "size_in_bytes": 231
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Dili",
+        "path_type": "hardlink",
+        "sha256": "e5f7021e45486642d5f1372ca8143c1ecb482c4a73ddacb7306194eac80dc4b0",
+        "sha256_in_prefix": "e5f7021e45486642d5f1372ca8143c1ecb482c4a73ddacb7306194eac80dc4b0",
+        "size_in_bytes": 170
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Dubai",
+        "path_type": "hardlink",
+        "sha256": "0d9ea5053e83188032a6fb4d301d5db688f43011e5b6b1f917a11b71a0da7b16",
+        "sha256_in_prefix": "0d9ea5053e83188032a6fb4d301d5db688f43011e5b6b1f917a11b71a0da7b16",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Dushanbe",
+        "path_type": "hardlink",
+        "sha256": "f2a6e7efaadff71bb8ecd61575f1af8e791fd8a67134de49f1e905897533dc04",
+        "sha256_in_prefix": "f2a6e7efaadff71bb8ecd61575f1af8e791fd8a67134de49f1e905897533dc04",
+        "size_in_bytes": 366
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Famagusta",
+        "path_type": "hardlink",
+        "sha256": "dfce5f6da467c7e99d11a5ea4b204a5410c328fcc218a6f29d662def9c300ae8",
+        "sha256_in_prefix": "dfce5f6da467c7e99d11a5ea4b204a5410c328fcc218a6f29d662def9c300ae8",
+        "size_in_bytes": 940
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Gaza",
+        "path_type": "hardlink",
+        "sha256": "f8f0bffe018e0da0c682fe4b2f31fba6d34b6cd752b4f931198e0b99e6ef70d5",
+        "sha256_in_prefix": "f8f0bffe018e0da0c682fe4b2f31fba6d34b6cd752b4f931198e0b99e6ef70d5",
+        "size_in_bytes": 2950
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Harbin",
+        "path_type": "hardlink",
+        "sha256": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "sha256_in_prefix": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "size_in_bytes": 393
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Hebron",
+        "path_type": "hardlink",
+        "sha256": "e05ba37ee13e10221780a5b8a6fd25c6ad999008fb8c3c2dd2b7b3b80d1f1738",
+        "sha256_in_prefix": "e05ba37ee13e10221780a5b8a6fd25c6ad999008fb8c3c2dd2b7b3b80d1f1738",
+        "size_in_bytes": 2968
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Ho_Chi_Minh",
+        "path_type": "hardlink",
+        "sha256": "47e45e54cade31c1131b44a27e37dee73f8f810a54b0a8d3e9d55b10acd3dec1",
+        "sha256_in_prefix": "47e45e54cade31c1131b44a27e37dee73f8f810a54b0a8d3e9d55b10acd3dec1",
+        "size_in_bytes": 236
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Hong_Kong",
+        "path_type": "hardlink",
+        "sha256": "f4068f73246db97417f73467453564c57d6646ce4909b9fa2536923efcd7eb4f",
+        "sha256_in_prefix": "f4068f73246db97417f73467453564c57d6646ce4909b9fa2536923efcd7eb4f",
+        "size_in_bytes": 775
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Hovd",
+        "path_type": "hardlink",
+        "sha256": "7aa02f0f645fb887d20e1b6a939f0c102223cf95f5e0e1d9eda3b8cf5e249dd9",
+        "sha256_in_prefix": "7aa02f0f645fb887d20e1b6a939f0c102223cf95f5e0e1d9eda3b8cf5e249dd9",
+        "size_in_bytes": 594
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Irkutsk",
+        "path_type": "hardlink",
+        "sha256": "b16c69f20fda49f15a9f867217db3afa9117e55830c62fe336feefc0dd3a5c8a",
+        "sha256_in_prefix": "b16c69f20fda49f15a9f867217db3afa9117e55830c62fe336feefc0dd3a5c8a",
+        "size_in_bytes": 760
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Istanbul",
+        "path_type": "hardlink",
+        "sha256": "2a7163b16b94806f69991348e7d0a60c46eb61b1f0305f5f4b83f613db10806f",
+        "sha256_in_prefix": "2a7163b16b94806f69991348e7d0a60c46eb61b1f0305f5f4b83f613db10806f",
+        "size_in_bytes": 1200
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Jakarta",
+        "path_type": "hardlink",
+        "sha256": "e2a099ea48b1f7166b88d219b326f7c44373d08909cd9723b44346946fd6a384",
+        "sha256_in_prefix": "e2a099ea48b1f7166b88d219b326f7c44373d08909cd9723b44346946fd6a384",
+        "size_in_bytes": 248
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Jayapura",
+        "path_type": "hardlink",
+        "sha256": "0546b4917d6239d7f413ebfbe35e61ee5d2542fe03042617ff77406d8990d315",
+        "sha256_in_prefix": "0546b4917d6239d7f413ebfbe35e61ee5d2542fe03042617ff77406d8990d315",
+        "size_in_bytes": 171
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Jerusalem",
+        "path_type": "hardlink",
+        "sha256": "9fcde8d584dea0585f5c8727aaf35f48a149e0dbd3a83bf6cef8bca9c14021e3",
+        "sha256_in_prefix": "9fcde8d584dea0585f5c8727aaf35f48a149e0dbd3a83bf6cef8bca9c14021e3",
+        "size_in_bytes": 1074
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Kabul",
+        "path_type": "hardlink",
+        "sha256": "a4d2304df8921bbd4118abeb84aaa8d71771724031f6f7dcc799c96a7acbf354",
+        "sha256_in_prefix": "a4d2304df8921bbd4118abeb84aaa8d71771724031f6f7dcc799c96a7acbf354",
+        "size_in_bytes": 159
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Kamchatka",
+        "path_type": "hardlink",
+        "sha256": "422c7cc77b3e9bc5137a2c3334f072fd942f0335ff69a8a1cff3f32df4e251a7",
+        "sha256_in_prefix": "422c7cc77b3e9bc5137a2c3334f072fd942f0335ff69a8a1cff3f32df4e251a7",
+        "size_in_bytes": 727
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Karachi",
+        "path_type": "hardlink",
+        "sha256": "ba3a38c2ffb7a1af6d7eb153e63b0b70461c8de19e051806d90c1d5e0fe28d4e",
+        "sha256_in_prefix": "ba3a38c2ffb7a1af6d7eb153e63b0b70461c8de19e051806d90c1d5e0fe28d4e",
+        "size_in_bytes": 266
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Kashgar",
+        "path_type": "hardlink",
+        "sha256": "849cafd377611cc2fc2b41891ab63c6fb3343949045db961fd16267593315ad4",
+        "sha256_in_prefix": "849cafd377611cc2fc2b41891ab63c6fb3343949045db961fd16267593315ad4",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Kathmandu",
+        "path_type": "hardlink",
+        "sha256": "76b8f1bfe072231a1d9e7f8501310e27c0d08048c48f7422860b6477c142c438",
+        "sha256_in_prefix": "76b8f1bfe072231a1d9e7f8501310e27c0d08048c48f7422860b6477c142c438",
+        "size_in_bytes": 161
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Katmandu",
+        "path_type": "hardlink",
+        "sha256": "76b8f1bfe072231a1d9e7f8501310e27c0d08048c48f7422860b6477c142c438",
+        "sha256_in_prefix": "76b8f1bfe072231a1d9e7f8501310e27c0d08048c48f7422860b6477c142c438",
+        "size_in_bytes": 161
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Khandyga",
+        "path_type": "hardlink",
+        "sha256": "7dd1033ac0c990bb843726ea217b53888e24d9edb874a1c37c14f0c3d02d6d2c",
+        "sha256_in_prefix": "7dd1033ac0c990bb843726ea217b53888e24d9edb874a1c37c14f0c3d02d6d2c",
+        "size_in_bytes": 775
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Kolkata",
+        "path_type": "hardlink",
+        "sha256": "3a00bdbe1bc4959e727567c730ba51b03455ecd455f7c190c5ad14386eb79b0d",
+        "sha256_in_prefix": "3a00bdbe1bc4959e727567c730ba51b03455ecd455f7c190c5ad14386eb79b0d",
+        "size_in_bytes": 220
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Krasnoyarsk",
+        "path_type": "hardlink",
+        "sha256": "6ee348e52d60ede79d2be3e99eb2e40451590d4c82b47c5cc570d0185d80468b",
+        "sha256_in_prefix": "6ee348e52d60ede79d2be3e99eb2e40451590d4c82b47c5cc570d0185d80468b",
+        "size_in_bytes": 741
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Kuala_Lumpur",
+        "path_type": "hardlink",
+        "sha256": "0954b2d9a301d94f4348024606a71bbcb2fa24d3cd3709f5bc8bca605039785d",
+        "sha256_in_prefix": "0954b2d9a301d94f4348024606a71bbcb2fa24d3cd3709f5bc8bca605039785d",
+        "size_in_bytes": 256
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Kuching",
+        "path_type": "hardlink",
+        "sha256": "dda8e0208df167e59cf9da9745348cc3ca904434a35e5481231c84fec0d11939",
+        "sha256_in_prefix": "dda8e0208df167e59cf9da9745348cc3ca904434a35e5481231c84fec0d11939",
+        "size_in_bytes": 320
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Kuwait",
+        "path_type": "hardlink",
+        "sha256": "46853e94276af2eea8e86c2f152a871c092df195dc51273b8fc7091faa4b461c",
+        "sha256_in_prefix": "46853e94276af2eea8e86c2f152a871c092df195dc51273b8fc7091faa4b461c",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Macao",
+        "path_type": "hardlink",
+        "sha256": "9abf3d8bfc293285a102da99ac5d9219ca082dc530eab62b0e42143400deb3b1",
+        "sha256_in_prefix": "9abf3d8bfc293285a102da99ac5d9219ca082dc530eab62b0e42143400deb3b1",
+        "size_in_bytes": 791
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Macau",
+        "path_type": "hardlink",
+        "sha256": "9abf3d8bfc293285a102da99ac5d9219ca082dc530eab62b0e42143400deb3b1",
+        "sha256_in_prefix": "9abf3d8bfc293285a102da99ac5d9219ca082dc530eab62b0e42143400deb3b1",
+        "size_in_bytes": 791
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Magadan",
+        "path_type": "hardlink",
+        "sha256": "c00b9f30658bfecd40c369779b201f045b6b44e54f7acddd32836e0c4a0dc13f",
+        "sha256_in_prefix": "c00b9f30658bfecd40c369779b201f045b6b44e54f7acddd32836e0c4a0dc13f",
+        "size_in_bytes": 751
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Makassar",
+        "path_type": "hardlink",
+        "sha256": "355f63fd14ee894e3b9af26f7ca13c75a5c7e4015827c2a2e20bc70494b1c8b7",
+        "sha256_in_prefix": "355f63fd14ee894e3b9af26f7ca13c75a5c7e4015827c2a2e20bc70494b1c8b7",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Manila",
+        "path_type": "hardlink",
+        "sha256": "1681a62321489c79277c4d74dcf6e20fae46530b269d85b3179a06cacd3706a6",
+        "sha256_in_prefix": "1681a62321489c79277c4d74dcf6e20fae46530b269d85b3179a06cacd3706a6",
+        "size_in_bytes": 274
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Muscat",
+        "path_type": "hardlink",
+        "sha256": "0d9ea5053e83188032a6fb4d301d5db688f43011e5b6b1f917a11b71a0da7b16",
+        "sha256_in_prefix": "0d9ea5053e83188032a6fb4d301d5db688f43011e5b6b1f917a11b71a0da7b16",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Nicosia",
+        "path_type": "hardlink",
+        "sha256": "4d862a5a9f2c2b40300541c0a74c2eba2859b90d7d45776ddbc6ed877df33812",
+        "sha256_in_prefix": "4d862a5a9f2c2b40300541c0a74c2eba2859b90d7d45776ddbc6ed877df33812",
+        "size_in_bytes": 597
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Novokuznetsk",
+        "path_type": "hardlink",
+        "sha256": "6985bdae9731a5fff3ace65cdaf9a972a822b8244a30707594cae2a08e37282c",
+        "sha256_in_prefix": "6985bdae9731a5fff3ace65cdaf9a972a822b8244a30707594cae2a08e37282c",
+        "size_in_bytes": 726
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Novosibirsk",
+        "path_type": "hardlink",
+        "sha256": "2369f830212569df6c31cc8900073861d553e9ec1b851efd3a8000ba11097c26",
+        "sha256_in_prefix": "2369f830212569df6c31cc8900073861d553e9ec1b851efd3a8000ba11097c26",
+        "size_in_bytes": 753
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Omsk",
+        "path_type": "hardlink",
+        "sha256": "cbbbb8ec439b077c08f0cc4a1c145314cf8111966a846a730e0ef1e657302576",
+        "sha256_in_prefix": "cbbbb8ec439b077c08f0cc4a1c145314cf8111966a846a730e0ef1e657302576",
+        "size_in_bytes": 741
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Oral",
+        "path_type": "hardlink",
+        "sha256": "43e19ff39348bdd02d539d999207fbf2b5473e583ce71c8c7bd666f726e1d29a",
+        "sha256_in_prefix": "43e19ff39348bdd02d539d999207fbf2b5473e583ce71c8c7bd666f726e1d29a",
+        "size_in_bytes": 625
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Phnom_Penh",
+        "path_type": "hardlink",
+        "sha256": "cdc8e2c282d8bc9a5e9c3caf2fc45ff4e9e5cd18f5dec8cb873340ad7c584d64",
+        "sha256_in_prefix": "cdc8e2c282d8bc9a5e9c3caf2fc45ff4e9e5cd18f5dec8cb873340ad7c584d64",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Pontianak",
+        "path_type": "hardlink",
+        "sha256": "a34c748cd4e5c23894a80cc65ff1e5cef08caeedb3514460438c73a52f79c5db",
+        "sha256_in_prefix": "a34c748cd4e5c23894a80cc65ff1e5cef08caeedb3514460438c73a52f79c5db",
+        "size_in_bytes": 247
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Pyongyang",
+        "path_type": "hardlink",
+        "sha256": "3710b975af284d9e12b621509e5863969f454d1b8c33e5f0b2add8838cb4c640",
+        "sha256_in_prefix": "3710b975af284d9e12b621509e5863969f454d1b8c33e5f0b2add8838cb4c640",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Qatar",
+        "path_type": "hardlink",
+        "sha256": "6160d6575a371c75b19e6c25cf03160b9dc2f386583e42bf8189fdf8fd17c785",
+        "sha256_in_prefix": "6160d6575a371c75b19e6c25cf03160b9dc2f386583e42bf8189fdf8fd17c785",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Qostanay",
+        "path_type": "hardlink",
+        "sha256": "e6d6648f5a34a78bda444b0f3b4620222c3a7837f572a3b9db1fb410c83fd8be",
+        "sha256_in_prefix": "e6d6648f5a34a78bda444b0f3b4620222c3a7837f572a3b9db1fb410c83fd8be",
+        "size_in_bytes": 624
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Qyzylorda",
+        "path_type": "hardlink",
+        "sha256": "265b4a0c49ee1e62101987454c024c0c3a5d0c0fc7c6324e0071da57b905ae54",
+        "sha256_in_prefix": "265b4a0c49ee1e62101987454c024c0c3a5d0c0fc7c6324e0071da57b905ae54",
+        "size_in_bytes": 624
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Rangoon",
+        "path_type": "hardlink",
+        "sha256": "e89d835c811d4da44aa8b386782ce8828df085aa0ee8f25661a9881d2f00e90c",
+        "sha256_in_prefix": "e89d835c811d4da44aa8b386782ce8828df085aa0ee8f25661a9881d2f00e90c",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Riyadh",
+        "path_type": "hardlink",
+        "sha256": "46853e94276af2eea8e86c2f152a871c092df195dc51273b8fc7091faa4b461c",
+        "sha256_in_prefix": "46853e94276af2eea8e86c2f152a871c092df195dc51273b8fc7091faa4b461c",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Saigon",
+        "path_type": "hardlink",
+        "sha256": "47e45e54cade31c1131b44a27e37dee73f8f810a54b0a8d3e9d55b10acd3dec1",
+        "sha256_in_prefix": "47e45e54cade31c1131b44a27e37dee73f8f810a54b0a8d3e9d55b10acd3dec1",
+        "size_in_bytes": 236
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Sakhalin",
+        "path_type": "hardlink",
+        "sha256": "33f4c177ed378fedd873d2b0846128053c1227158ed653c11bb9ddb2dd7a3c6a",
+        "sha256_in_prefix": "33f4c177ed378fedd873d2b0846128053c1227158ed653c11bb9ddb2dd7a3c6a",
+        "size_in_bytes": 755
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Samarkand",
+        "path_type": "hardlink",
+        "sha256": "299feafba18c0d58096fc445a9cadb55c3c2d162dcce8942942e27640d4754d5",
+        "sha256_in_prefix": "299feafba18c0d58096fc445a9cadb55c3c2d162dcce8942942e27640d4754d5",
+        "size_in_bytes": 366
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Seoul",
+        "path_type": "hardlink",
+        "sha256": "64a70b6fbcc9b65e762dbd25eb89b6f40c137146edc8dbd4d081eafacdab78de",
+        "sha256_in_prefix": "64a70b6fbcc9b65e762dbd25eb89b6f40c137146edc8dbd4d081eafacdab78de",
+        "size_in_bytes": 415
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Shanghai",
+        "path_type": "hardlink",
+        "sha256": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "sha256_in_prefix": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "size_in_bytes": 393
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Singapore",
+        "path_type": "hardlink",
+        "sha256": "0954b2d9a301d94f4348024606a71bbcb2fa24d3cd3709f5bc8bca605039785d",
+        "sha256_in_prefix": "0954b2d9a301d94f4348024606a71bbcb2fa24d3cd3709f5bc8bca605039785d",
+        "size_in_bytes": 256
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Srednekolymsk",
+        "path_type": "hardlink",
+        "sha256": "d3a9a88deb456c37786a0d69f0d2b4160eab17638e9d93054510bdd0dd804d97",
+        "sha256_in_prefix": "d3a9a88deb456c37786a0d69f0d2b4160eab17638e9d93054510bdd0dd804d97",
+        "size_in_bytes": 742
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Taipei",
+        "path_type": "hardlink",
+        "sha256": "a04c2c72f4f76a83178d036dd97d157ee1f32e478e44dda7a5c10923687ee6cf",
+        "sha256_in_prefix": "a04c2c72f4f76a83178d036dd97d157ee1f32e478e44dda7a5c10923687ee6cf",
+        "size_in_bytes": 511
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Tashkent",
+        "path_type": "hardlink",
+        "sha256": "d2fa4dda023d198e74cf59de6bacc23c57f607a542bba5d0407c7897aae19d32",
+        "sha256_in_prefix": "d2fa4dda023d198e74cf59de6bacc23c57f607a542bba5d0407c7897aae19d32",
+        "size_in_bytes": 366
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Tbilisi",
+        "path_type": "hardlink",
+        "sha256": "38dfd4cefd954d293a99179f354f9a23eaa4aad0a8517ea810256aa5e4b8d9e2",
+        "sha256_in_prefix": "38dfd4cefd954d293a99179f354f9a23eaa4aad0a8517ea810256aa5e4b8d9e2",
+        "size_in_bytes": 629
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Tehran",
+        "path_type": "hardlink",
+        "sha256": "a332e584d5f3a49099c7b6dcf95a5c98d76076d9fa94fb45e9ff6a91a0c4c9c2",
+        "sha256_in_prefix": "a332e584d5f3a49099c7b6dcf95a5c98d76076d9fa94fb45e9ff6a91a0c4c9c2",
+        "size_in_bytes": 812
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Tel_Aviv",
+        "path_type": "hardlink",
+        "sha256": "9fcde8d584dea0585f5c8727aaf35f48a149e0dbd3a83bf6cef8bca9c14021e3",
+        "sha256_in_prefix": "9fcde8d584dea0585f5c8727aaf35f48a149e0dbd3a83bf6cef8bca9c14021e3",
+        "size_in_bytes": 1074
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Thimbu",
+        "path_type": "hardlink",
+        "sha256": "37a77fbdf16f60e45f327af57c7263612b780c139149b2e2ff64feaf67490672",
+        "sha256_in_prefix": "37a77fbdf16f60e45f327af57c7263612b780c139149b2e2ff64feaf67490672",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Thimphu",
+        "path_type": "hardlink",
+        "sha256": "37a77fbdf16f60e45f327af57c7263612b780c139149b2e2ff64feaf67490672",
+        "sha256_in_prefix": "37a77fbdf16f60e45f327af57c7263612b780c139149b2e2ff64feaf67490672",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Tokyo",
+        "path_type": "hardlink",
+        "sha256": "59a3871430f0d3b93e619fa30a43a41d1e88bdd49ff26f09d0f405a500706f96",
+        "sha256_in_prefix": "59a3871430f0d3b93e619fa30a43a41d1e88bdd49ff26f09d0f405a500706f96",
+        "size_in_bytes": 213
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Tomsk",
+        "path_type": "hardlink",
+        "sha256": "05fec6a054dc51e3f6858cae629aee2638b7ded704a0b3fef34a37f00ea2e335",
+        "sha256_in_prefix": "05fec6a054dc51e3f6858cae629aee2638b7ded704a0b3fef34a37f00ea2e335",
+        "size_in_bytes": 753
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Ujung_Pandang",
+        "path_type": "hardlink",
+        "sha256": "355f63fd14ee894e3b9af26f7ca13c75a5c7e4015827c2a2e20bc70494b1c8b7",
+        "sha256_in_prefix": "355f63fd14ee894e3b9af26f7ca13c75a5c7e4015827c2a2e20bc70494b1c8b7",
+        "size_in_bytes": 190
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Ulaanbaatar",
+        "path_type": "hardlink",
+        "sha256": "fbe23c3fafdee01b5121edf009290fb701cebbf93dacfb30f8aa90287242f6f3",
+        "sha256_in_prefix": "fbe23c3fafdee01b5121edf009290fb701cebbf93dacfb30f8aa90287242f6f3",
+        "size_in_bytes": 594
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Ulan_Bator",
+        "path_type": "hardlink",
+        "sha256": "fbe23c3fafdee01b5121edf009290fb701cebbf93dacfb30f8aa90287242f6f3",
+        "sha256_in_prefix": "fbe23c3fafdee01b5121edf009290fb701cebbf93dacfb30f8aa90287242f6f3",
+        "size_in_bytes": 594
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Urumqi",
+        "path_type": "hardlink",
+        "sha256": "849cafd377611cc2fc2b41891ab63c6fb3343949045db961fd16267593315ad4",
+        "sha256_in_prefix": "849cafd377611cc2fc2b41891ab63c6fb3343949045db961fd16267593315ad4",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Ust-Nera",
+        "path_type": "hardlink",
+        "sha256": "e8d92e575cce9acfb8a87421abe70673e72a11580a1e4eea77730b0ccf9ed810",
+        "sha256_in_prefix": "e8d92e575cce9acfb8a87421abe70673e72a11580a1e4eea77730b0ccf9ed810",
+        "size_in_bytes": 771
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Vientiane",
+        "path_type": "hardlink",
+        "sha256": "cdc8e2c282d8bc9a5e9c3caf2fc45ff4e9e5cd18f5dec8cb873340ad7c584d64",
+        "sha256_in_prefix": "cdc8e2c282d8bc9a5e9c3caf2fc45ff4e9e5cd18f5dec8cb873340ad7c584d64",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Vladivostok",
+        "path_type": "hardlink",
+        "sha256": "ce4397b840e0a715fc1d01a00e587d49b010cc739a3715f65d223a63880c0fe9",
+        "sha256_in_prefix": "ce4397b840e0a715fc1d01a00e587d49b010cc739a3715f65d223a63880c0fe9",
+        "size_in_bytes": 742
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Yakutsk",
+        "path_type": "hardlink",
+        "sha256": "c43eb3038136dbc742d6621443b70c3bef4b39149f13e1689346b01831ba8ee9",
+        "sha256_in_prefix": "c43eb3038136dbc742d6621443b70c3bef4b39149f13e1689346b01831ba8ee9",
+        "size_in_bytes": 741
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Yangon",
+        "path_type": "hardlink",
+        "sha256": "e89d835c811d4da44aa8b386782ce8828df085aa0ee8f25661a9881d2f00e90c",
+        "sha256_in_prefix": "e89d835c811d4da44aa8b386782ce8828df085aa0ee8f25661a9881d2f00e90c",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Yekaterinburg",
+        "path_type": "hardlink",
+        "sha256": "ab5ede532a8e10ad8b25829760b089ab2963faf99a086daf48d32db6aad04d19",
+        "sha256_in_prefix": "ab5ede532a8e10ad8b25829760b089ab2963faf99a086daf48d32db6aad04d19",
+        "size_in_bytes": 760
+      },
+      {
+        "_path": "share/zoneinfo/Asia/Yerevan",
+        "path_type": "hardlink",
+        "sha256": "a4b10175c840f07f65fbd85d03a1631e6c1a8f94f58eea4ad2ef9ba2bd4a29ad",
+        "sha256_in_prefix": "a4b10175c840f07f65fbd85d03a1631e6c1a8f94f58eea4ad2ef9ba2bd4a29ad",
+        "size_in_bytes": 708
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Azores",
+        "path_type": "hardlink",
+        "sha256": "e97069fab820f211114ded9cf9b4ca6a160f9640e7dac44e06eaa8f7001db4f1",
+        "sha256_in_prefix": "e97069fab820f211114ded9cf9b4ca6a160f9640e7dac44e06eaa8f7001db4f1",
+        "size_in_bytes": 1401
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Bermuda",
+        "path_type": "hardlink",
+        "sha256": "3eec6a0f6703f7d3f38dbf211fdf43c2cd39dddff35e76478de1f4919f0b48b2",
+        "sha256_in_prefix": "3eec6a0f6703f7d3f38dbf211fdf43c2cd39dddff35e76478de1f4919f0b48b2",
+        "size_in_bytes": 1024
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Canary",
+        "path_type": "hardlink",
+        "sha256": "5cc9b1065b1c3c85978626ae2b2fdde5bc57e318cd30cfb9570f381706644f4d",
+        "sha256_in_prefix": "5cc9b1065b1c3c85978626ae2b2fdde5bc57e318cd30cfb9570f381706644f4d",
+        "size_in_bytes": 478
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Cape_Verde",
+        "path_type": "hardlink",
+        "sha256": "139b2ceb1a48a43d20fd5103b053058be96db1e6e9f7c3c14a950ba15c480325",
+        "sha256_in_prefix": "139b2ceb1a48a43d20fd5103b053058be96db1e6e9f7c3c14a950ba15c480325",
+        "size_in_bytes": 175
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Faeroe",
+        "path_type": "hardlink",
+        "sha256": "230d2a074981baf887e70dd0cbc8dac4239eb34ed91e1db0916f0c3d4589aa3d",
+        "sha256_in_prefix": "230d2a074981baf887e70dd0cbc8dac4239eb34ed91e1db0916f0c3d4589aa3d",
+        "size_in_bytes": 441
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Faroe",
+        "path_type": "hardlink",
+        "sha256": "230d2a074981baf887e70dd0cbc8dac4239eb34ed91e1db0916f0c3d4589aa3d",
+        "sha256_in_prefix": "230d2a074981baf887e70dd0cbc8dac4239eb34ed91e1db0916f0c3d4589aa3d",
+        "size_in_bytes": 441
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Jan_Mayen",
+        "path_type": "hardlink",
+        "sha256": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "sha256_in_prefix": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "size_in_bytes": 705
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Madeira",
+        "path_type": "hardlink",
+        "sha256": "d85def2e6a7b3939b864c48bc72215410ea25de19490a28f7947621a6a95bae2",
+        "sha256_in_prefix": "d85def2e6a7b3939b864c48bc72215410ea25de19490a28f7947621a6a95bae2",
+        "size_in_bytes": 1372
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Reykjavik",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/South_Georgia",
+        "path_type": "hardlink",
+        "sha256": "90f19f08b403d82ebf5dce53c809aa9973fe19874b2cfb9ca419f74bbc9b5aef",
+        "sha256_in_prefix": "90f19f08b403d82ebf5dce53c809aa9973fe19874b2cfb9ca419f74bbc9b5aef",
+        "size_in_bytes": 132
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/St_Helena",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Atlantic/Stanley",
+        "path_type": "hardlink",
+        "sha256": "42a41df085a494d6a930a8cde6f17bbef567e0afb297754abcce7390229a6c23",
+        "sha256_in_prefix": "42a41df085a494d6a930a8cde6f17bbef567e0afb297754abcce7390229a6c23",
+        "size_in_bytes": 789
+      },
+      {
+        "_path": "share/zoneinfo/Australia/ACT",
+        "path_type": "hardlink",
+        "sha256": "820d45a868a88f81c731d5b2c758b4ed000039b6260a80433f8e0f094a604b59",
+        "sha256_in_prefix": "820d45a868a88f81c731d5b2c758b4ed000039b6260a80433f8e0f094a604b59",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Adelaide",
+        "path_type": "hardlink",
+        "sha256": "1a4d52746455981db7dc8f961135c0302673ecbec7573a0de1a52821c80daf78",
+        "sha256_in_prefix": "1a4d52746455981db7dc8f961135c0302673ecbec7573a0de1a52821c80daf78",
+        "size_in_bytes": 921
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Brisbane",
+        "path_type": "hardlink",
+        "sha256": "da4556cfd088feab5f75be7983488be7d814042ee59cedc651a948431b470036",
+        "sha256_in_prefix": "da4556cfd088feab5f75be7983488be7d814042ee59cedc651a948431b470036",
+        "size_in_bytes": 289
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Broken_Hill",
+        "path_type": "hardlink",
+        "sha256": "77393d2ef180ff1452b670088c016e4c9f14c33feceea1961909a25cf803b0b6",
+        "sha256_in_prefix": "77393d2ef180ff1452b670088c016e4c9f14c33feceea1961909a25cf803b0b6",
+        "size_in_bytes": 941
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Canberra",
+        "path_type": "hardlink",
+        "sha256": "820d45a868a88f81c731d5b2c758b4ed000039b6260a80433f8e0f094a604b59",
+        "sha256_in_prefix": "820d45a868a88f81c731d5b2c758b4ed000039b6260a80433f8e0f094a604b59",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Currie",
+        "path_type": "hardlink",
+        "sha256": "d4801581fd00037b013d71616b119fbbd510fdca5de06369b10f718a8da5e32d",
+        "sha256_in_prefix": "d4801581fd00037b013d71616b119fbbd510fdca5de06369b10f718a8da5e32d",
+        "size_in_bytes": 1003
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Darwin",
+        "path_type": "hardlink",
+        "sha256": "6687b16e181d52557895e57e76106ee80c43564272e37c6b3dbf5443711009d2",
+        "sha256_in_prefix": "6687b16e181d52557895e57e76106ee80c43564272e37c6b3dbf5443711009d2",
+        "size_in_bytes": 234
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Eucla",
+        "path_type": "hardlink",
+        "sha256": "dcdaac15f33347afa54943d588d5c100ec893eaca8922b2c7bbb835eead44699",
+        "sha256_in_prefix": "dcdaac15f33347afa54943d588d5c100ec893eaca8922b2c7bbb835eead44699",
+        "size_in_bytes": 314
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Hobart",
+        "path_type": "hardlink",
+        "sha256": "d4801581fd00037b013d71616b119fbbd510fdca5de06369b10f718a8da5e32d",
+        "sha256_in_prefix": "d4801581fd00037b013d71616b119fbbd510fdca5de06369b10f718a8da5e32d",
+        "size_in_bytes": 1003
+      },
+      {
+        "_path": "share/zoneinfo/Australia/LHI",
+        "path_type": "hardlink",
+        "sha256": "f368bd25659c0293d02bb79ec7dac7d5b73a92dffafce14b4dd2ffb8ba11aada",
+        "sha256_in_prefix": "f368bd25659c0293d02bb79ec7dac7d5b73a92dffafce14b4dd2ffb8ba11aada",
+        "size_in_bytes": 692
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Lindeman",
+        "path_type": "hardlink",
+        "sha256": "887902734409ee26907df8934d7415276b30b02ed02712d430740e1821659139",
+        "sha256_in_prefix": "887902734409ee26907df8934d7415276b30b02ed02712d430740e1821659139",
+        "size_in_bytes": 325
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Lord_Howe",
+        "path_type": "hardlink",
+        "sha256": "f368bd25659c0293d02bb79ec7dac7d5b73a92dffafce14b4dd2ffb8ba11aada",
+        "sha256_in_prefix": "f368bd25659c0293d02bb79ec7dac7d5b73a92dffafce14b4dd2ffb8ba11aada",
+        "size_in_bytes": 692
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Melbourne",
+        "path_type": "hardlink",
+        "sha256": "5fb24f3048ff4985b27e0585324a7a14e993e867f28d1fa517d8451a04dabe71",
+        "sha256_in_prefix": "5fb24f3048ff4985b27e0585324a7a14e993e867f28d1fa517d8451a04dabe71",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "share/zoneinfo/Australia/NSW",
+        "path_type": "hardlink",
+        "sha256": "820d45a868a88f81c731d5b2c758b4ed000039b6260a80433f8e0f094a604b59",
+        "sha256_in_prefix": "820d45a868a88f81c731d5b2c758b4ed000039b6260a80433f8e0f094a604b59",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "share/zoneinfo/Australia/North",
+        "path_type": "hardlink",
+        "sha256": "6687b16e181d52557895e57e76106ee80c43564272e37c6b3dbf5443711009d2",
+        "sha256_in_prefix": "6687b16e181d52557895e57e76106ee80c43564272e37c6b3dbf5443711009d2",
+        "size_in_bytes": 234
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Perth",
+        "path_type": "hardlink",
+        "sha256": "66cb9e95c042d587d6ba01f60ab94e5d07120c3e20194242a1b0755be6aea47a",
+        "sha256_in_prefix": "66cb9e95c042d587d6ba01f60ab94e5d07120c3e20194242a1b0755be6aea47a",
+        "size_in_bytes": 306
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Queensland",
+        "path_type": "hardlink",
+        "sha256": "da4556cfd088feab5f75be7983488be7d814042ee59cedc651a948431b470036",
+        "sha256_in_prefix": "da4556cfd088feab5f75be7983488be7d814042ee59cedc651a948431b470036",
+        "size_in_bytes": 289
+      },
+      {
+        "_path": "share/zoneinfo/Australia/South",
+        "path_type": "hardlink",
+        "sha256": "1a4d52746455981db7dc8f961135c0302673ecbec7573a0de1a52821c80daf78",
+        "sha256_in_prefix": "1a4d52746455981db7dc8f961135c0302673ecbec7573a0de1a52821c80daf78",
+        "size_in_bytes": 921
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Sydney",
+        "path_type": "hardlink",
+        "sha256": "820d45a868a88f81c731d5b2c758b4ed000039b6260a80433f8e0f094a604b59",
+        "sha256_in_prefix": "820d45a868a88f81c731d5b2c758b4ed000039b6260a80433f8e0f094a604b59",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Tasmania",
+        "path_type": "hardlink",
+        "sha256": "d4801581fd00037b013d71616b119fbbd510fdca5de06369b10f718a8da5e32d",
+        "sha256_in_prefix": "d4801581fd00037b013d71616b119fbbd510fdca5de06369b10f718a8da5e32d",
+        "size_in_bytes": 1003
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Victoria",
+        "path_type": "hardlink",
+        "sha256": "5fb24f3048ff4985b27e0585324a7a14e993e867f28d1fa517d8451a04dabe71",
+        "sha256_in_prefix": "5fb24f3048ff4985b27e0585324a7a14e993e867f28d1fa517d8451a04dabe71",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "share/zoneinfo/Australia/West",
+        "path_type": "hardlink",
+        "sha256": "66cb9e95c042d587d6ba01f60ab94e5d07120c3e20194242a1b0755be6aea47a",
+        "sha256_in_prefix": "66cb9e95c042d587d6ba01f60ab94e5d07120c3e20194242a1b0755be6aea47a",
+        "size_in_bytes": 306
+      },
+      {
+        "_path": "share/zoneinfo/Australia/Yancowinna",
+        "path_type": "hardlink",
+        "sha256": "77393d2ef180ff1452b670088c016e4c9f14c33feceea1961909a25cf803b0b6",
+        "sha256_in_prefix": "77393d2ef180ff1452b670088c016e4c9f14c33feceea1961909a25cf803b0b6",
+        "size_in_bytes": 941
+      },
+      {
+        "_path": "share/zoneinfo/Brazil/Acre",
+        "path_type": "hardlink",
+        "sha256": "563b9052bebaf2986ae5b707e34afde013e7641287cc97ff31005f33a0dbf7a5",
+        "sha256_in_prefix": "563b9052bebaf2986ae5b707e34afde013e7641287cc97ff31005f33a0dbf7a5",
+        "size_in_bytes": 418
+      },
+      {
+        "_path": "share/zoneinfo/Brazil/DeNoronha",
+        "path_type": "hardlink",
+        "sha256": "434af71ad039cb644690e8f9e8e4d91b9b6e072d41ea47db872ac9a8281fdbb8",
+        "sha256_in_prefix": "434af71ad039cb644690e8f9e8e4d91b9b6e072d41ea47db872ac9a8281fdbb8",
+        "size_in_bytes": 484
+      },
+      {
+        "_path": "share/zoneinfo/Brazil/East",
+        "path_type": "hardlink",
+        "sha256": "fa2ceb222f065c0289f3997ff0c54ba05a74a599b4522870fa86a96e24e18891",
+        "sha256_in_prefix": "fa2ceb222f065c0289f3997ff0c54ba05a74a599b4522870fa86a96e24e18891",
+        "size_in_bytes": 952
+      },
+      {
+        "_path": "share/zoneinfo/Brazil/West",
+        "path_type": "hardlink",
+        "sha256": "f6482b869af207de18395a2c8499628a20d27fd9b08dbdce6705f41eeb0d46b9",
+        "sha256_in_prefix": "f6482b869af207de18395a2c8499628a20d27fd9b08dbdce6705f41eeb0d46b9",
+        "size_in_bytes": 412
+      },
+      {
+        "_path": "share/zoneinfo/CET",
+        "path_type": "hardlink",
+        "sha256": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "sha256_in_prefix": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "size_in_bytes": 1103
+      },
+      {
+        "_path": "share/zoneinfo/CST6CDT",
+        "path_type": "hardlink",
+        "sha256": "c27b739ff46a7df0594e120d725b439217e11e44ea9a50cdc49130383b5482e7",
+        "sha256_in_prefix": "c27b739ff46a7df0594e120d725b439217e11e44ea9a50cdc49130383b5482e7",
+        "size_in_bytes": 1754
+      },
+      {
+        "_path": "share/zoneinfo/Canada/Atlantic",
+        "path_type": "hardlink",
+        "sha256": "90ee5a841336a132df592e0a5f5e456ca5dfa39c20f9ff6fc35fe130e2121a28",
+        "sha256_in_prefix": "90ee5a841336a132df592e0a5f5e456ca5dfa39c20f9ff6fc35fe130e2121a28",
+        "size_in_bytes": 1672
+      },
+      {
+        "_path": "share/zoneinfo/Canada/Central",
+        "path_type": "hardlink",
+        "sha256": "00dcf0606054d4f927416e0b47e1fdda2e5ce036fde4b53e51084f8566428c3a",
+        "sha256_in_prefix": "00dcf0606054d4f927416e0b47e1fdda2e5ce036fde4b53e51084f8566428c3a",
+        "size_in_bytes": 1294
+      },
+      {
+        "_path": "share/zoneinfo/Canada/Eastern",
+        "path_type": "hardlink",
+        "sha256": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "sha256_in_prefix": "815ab4db7a1b1292867d2f924b718e1bba32455ce9f92205db2feb65029c6761",
+        "size_in_bytes": 1717
+      },
+      {
+        "_path": "share/zoneinfo/Canada/Mountain",
+        "path_type": "hardlink",
+        "sha256": "0eada6c5c48d59984c591ab1c30b4c71aab000818cc243b3cfe996f1f26c715f",
+        "sha256_in_prefix": "0eada6c5c48d59984c591ab1c30b4c71aab000818cc243b3cfe996f1f26c715f",
+        "size_in_bytes": 970
+      },
+      {
+        "_path": "share/zoneinfo/Canada/Newfoundland",
+        "path_type": "hardlink",
+        "sha256": "bfdf6afc014c3e597930cc4ca7df1aa98e347268acdb07224df4eab36fe46f49",
+        "sha256_in_prefix": "bfdf6afc014c3e597930cc4ca7df1aa98e347268acdb07224df4eab36fe46f49",
+        "size_in_bytes": 1878
+      },
+      {
+        "_path": "share/zoneinfo/Canada/Pacific",
+        "path_type": "hardlink",
+        "sha256": "129a2eef5b147dfbc7075addef04f492bbe8de8917015e39fd359c385a72dba4",
+        "sha256_in_prefix": "129a2eef5b147dfbc7075addef04f492bbe8de8917015e39fd359c385a72dba4",
+        "size_in_bytes": 1330
+      },
+      {
+        "_path": "share/zoneinfo/Canada/Saskatchewan",
+        "path_type": "hardlink",
+        "sha256": "fc91ee9ecdb6e6213e4c773d345a7e441ab83d650b02e1b0d8e2dba4e07f50cc",
+        "sha256_in_prefix": "fc91ee9ecdb6e6213e4c773d345a7e441ab83d650b02e1b0d8e2dba4e07f50cc",
+        "size_in_bytes": 638
+      },
+      {
+        "_path": "share/zoneinfo/Canada/Yukon",
+        "path_type": "hardlink",
+        "sha256": "0b26388cd7747f335275fd4795819f6a4b40a661fbd6d44d465a4e10edf60c6b",
+        "sha256_in_prefix": "0b26388cd7747f335275fd4795819f6a4b40a661fbd6d44d465a4e10edf60c6b",
+        "size_in_bytes": 1029
+      },
+      {
+        "_path": "share/zoneinfo/Chile/Continental",
+        "path_type": "hardlink",
+        "sha256": "fd006953c2b442a2e1e66db2a967dd932a4824390f01cddd9c801ce63450c715",
+        "sha256_in_prefix": "fd006953c2b442a2e1e66db2a967dd932a4824390f01cddd9c801ce63450c715",
+        "size_in_bytes": 1354
+      },
+      {
+        "_path": "share/zoneinfo/Chile/EasterIsland",
+        "path_type": "hardlink",
+        "sha256": "13054cef85e3b1ba0f5712bd6d699d7789d3aedbdab0fd7394b771acc07f61a1",
+        "sha256_in_prefix": "13054cef85e3b1ba0f5712bd6d699d7789d3aedbdab0fd7394b771acc07f61a1",
+        "size_in_bytes": 1174
+      },
+      {
+        "_path": "share/zoneinfo/Cuba",
+        "path_type": "hardlink",
+        "sha256": "9ace6b0aeab6c81338f55993ca632d15037773968137596477c8e3cca767366f",
+        "sha256_in_prefix": "9ace6b0aeab6c81338f55993ca632d15037773968137596477c8e3cca767366f",
+        "size_in_bytes": 1117
+      },
+      {
+        "_path": "share/zoneinfo/EET",
+        "path_type": "hardlink",
+        "sha256": "f1fd678b0548e329b38934f6281255e698dfa761ad1ff841f6ccb79606c61345",
+        "sha256_in_prefix": "f1fd678b0548e329b38934f6281255e698dfa761ad1ff841f6ccb79606c61345",
+        "size_in_bytes": 682
+      },
+      {
+        "_path": "share/zoneinfo/EST",
+        "path_type": "hardlink",
+        "sha256": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "sha256_in_prefix": "a78d73067ba3cbd94f8a23dfdd6aa8b68cb33b18484bc17b4e20ea1aec2f0a81",
+        "size_in_bytes": 149
+      },
+      {
+        "_path": "share/zoneinfo/EST5EDT",
+        "path_type": "hardlink",
+        "sha256": "d7f2206b3a45989fc9ad63d558922532fa7352280d5f87176bf1db79cb1d1fa9",
+        "sha256_in_prefix": "d7f2206b3a45989fc9ad63d558922532fa7352280d5f87176bf1db79cb1d1fa9",
+        "size_in_bytes": 1744
+      },
+      {
+        "_path": "share/zoneinfo/Egypt",
+        "path_type": "hardlink",
+        "sha256": "89cb9a36212fb82e933dcd9faa10efdfa969a29ec80c32063bbb4518c033d1be",
+        "sha256_in_prefix": "89cb9a36212fb82e933dcd9faa10efdfa969a29ec80c32063bbb4518c033d1be",
+        "size_in_bytes": 1309
+      },
+      {
+        "_path": "share/zoneinfo/Eire",
+        "path_type": "hardlink",
+        "sha256": "11c00336e02f1318fe764ab29467c5f2afefbfffa644fa8dd24f5b083b495b71",
+        "sha256_in_prefix": "11c00336e02f1318fe764ab29467c5f2afefbfffa644fa8dd24f5b083b495b71",
+        "size_in_bytes": 1496
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+0",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+1",
+        "path_type": "hardlink",
+        "sha256": "e4bf68f1311482d075d69a086a0f39bd176ad3c2cc0d9999e833e7ed4a8f2ff8",
+        "sha256_in_prefix": "e4bf68f1311482d075d69a086a0f39bd176ad3c2cc0d9999e833e7ed4a8f2ff8",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+10",
+        "path_type": "hardlink",
+        "sha256": "22f0718aa414efaab335bbb1468f0087dacf4124464062a9fd246ce6ed4f3e43",
+        "sha256_in_prefix": "22f0718aa414efaab335bbb1468f0087dacf4124464062a9fd246ce6ed4f3e43",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+11",
+        "path_type": "hardlink",
+        "sha256": "f4c7c5a45a7faedf4f92c323436dd53a58abde1cd39672f3ff9576b5fa2785b5",
+        "sha256_in_prefix": "f4c7c5a45a7faedf4f92c323436dd53a58abde1cd39672f3ff9576b5fa2785b5",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+12",
+        "path_type": "hardlink",
+        "sha256": "976e97085a7d21b8171af330ecd1e01f32196c7af2d81e6a1987e13031c556bc",
+        "sha256_in_prefix": "976e97085a7d21b8171af330ecd1e01f32196c7af2d81e6a1987e13031c556bc",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+2",
+        "path_type": "hardlink",
+        "sha256": "61b6ea1fb07a8cda101088f2578fbc6b67170fd9460b7bd02a7124636b9c0c62",
+        "sha256_in_prefix": "61b6ea1fb07a8cda101088f2578fbc6b67170fd9460b7bd02a7124636b9c0c62",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+3",
+        "path_type": "hardlink",
+        "sha256": "ab70fd0cb7e64c1500a3860c9cd50d5142ab024292c0ce50faf7ac77d03a4994",
+        "sha256_in_prefix": "ab70fd0cb7e64c1500a3860c9cd50d5142ab024292c0ce50faf7ac77d03a4994",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+4",
+        "path_type": "hardlink",
+        "sha256": "52084a304de569748367babbe180dbe0570b9f336a5d0c9d719a501efb2c3f69",
+        "sha256_in_prefix": "52084a304de569748367babbe180dbe0570b9f336a5d0c9d719a501efb2c3f69",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+5",
+        "path_type": "hardlink",
+        "sha256": "4d9e6a6a810b96ccd6fd9e4576a00430a93c63fc6ee5785904d654728e794ab3",
+        "sha256_in_prefix": "4d9e6a6a810b96ccd6fd9e4576a00430a93c63fc6ee5785904d654728e794ab3",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+6",
+        "path_type": "hardlink",
+        "sha256": "ff69372d9e71f21563330c260b1e86a94c16fafd48bce901ac98d81f96c3e90c",
+        "sha256_in_prefix": "ff69372d9e71f21563330c260b1e86a94c16fafd48bce901ac98d81f96c3e90c",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+7",
+        "path_type": "hardlink",
+        "sha256": "0e2f09e37d161abf7c5b0f79b5d7c8a3c846c645507c9be5c79e5a9ec0eea1e4",
+        "sha256_in_prefix": "0e2f09e37d161abf7c5b0f79b5d7c8a3c846c645507c9be5c79e5a9ec0eea1e4",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+8",
+        "path_type": "hardlink",
+        "sha256": "388225505859c0bd9cb71ddfc4835b6361c30c099243b8b66405205fb1318e0c",
+        "sha256_in_prefix": "388225505859c0bd9cb71ddfc4835b6361c30c099243b8b66405205fb1318e0c",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT+9",
+        "path_type": "hardlink",
+        "sha256": "d6fa642283ea062c035b31fe7cb171c0d6e674a458ee6a9d889858408995c5ac",
+        "sha256_in_prefix": "d6fa642283ea062c035b31fe7cb171c0d6e674a458ee6a9d889858408995c5ac",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-0",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-1",
+        "path_type": "hardlink",
+        "sha256": "4bcd52f59d3e57ed01e54fb44b43e76f1f1fbf6887b701352eb95993e7242eda",
+        "sha256_in_prefix": "4bcd52f59d3e57ed01e54fb44b43e76f1f1fbf6887b701352eb95993e7242eda",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-10",
+        "path_type": "hardlink",
+        "sha256": "56f746e48a5707fc495f8a26cdfaeb1db964454ce46c26573e14eb2e781ceef9",
+        "sha256_in_prefix": "56f746e48a5707fc495f8a26cdfaeb1db964454ce46c26573e14eb2e781ceef9",
+        "size_in_bytes": 115
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-11",
+        "path_type": "hardlink",
+        "sha256": "dac60b7d5b83152cbb29cd5638f898d44aaab87c395f1e076c303540e2f585ce",
+        "sha256_in_prefix": "dac60b7d5b83152cbb29cd5638f898d44aaab87c395f1e076c303540e2f585ce",
+        "size_in_bytes": 115
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-12",
+        "path_type": "hardlink",
+        "sha256": "89f1d5864e5f733646dc60f2fcdbfb62c2cd6b17fcb2d07832bce05940883655",
+        "sha256_in_prefix": "89f1d5864e5f733646dc60f2fcdbfb62c2cd6b17fcb2d07832bce05940883655",
+        "size_in_bytes": 115
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-13",
+        "path_type": "hardlink",
+        "sha256": "08c90e45d5ec692c8bfb83749f7ec2c9cd650abdb666c5b2ba0f7f41955ed04d",
+        "sha256_in_prefix": "08c90e45d5ec692c8bfb83749f7ec2c9cd650abdb666c5b2ba0f7f41955ed04d",
+        "size_in_bytes": 115
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-14",
+        "path_type": "hardlink",
+        "sha256": "34ad3b125c2e794d0e3fc80e46d717514ba0ff7bf8774e2ec5f5473149cb33d5",
+        "sha256_in_prefix": "34ad3b125c2e794d0e3fc80e46d717514ba0ff7bf8774e2ec5f5473149cb33d5",
+        "size_in_bytes": 115
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-2",
+        "path_type": "hardlink",
+        "sha256": "40c4e830b7227f54b848d3ce33132d04ba9cd6c9146272216d40232847407fdc",
+        "sha256_in_prefix": "40c4e830b7227f54b848d3ce33132d04ba9cd6c9146272216d40232847407fdc",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-3",
+        "path_type": "hardlink",
+        "sha256": "d7418cbdfba5689c034221e258426253f6144728c37cf725e6e827601ba03771",
+        "sha256_in_prefix": "d7418cbdfba5689c034221e258426253f6144728c37cf725e6e827601ba03771",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-4",
+        "path_type": "hardlink",
+        "sha256": "73a2b1defe3519192bbe4cbc93bd5d6ff5096e9cb2a763990ac8c34af8e4afab",
+        "sha256_in_prefix": "73a2b1defe3519192bbe4cbc93bd5d6ff5096e9cb2a763990ac8c34af8e4afab",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-5",
+        "path_type": "hardlink",
+        "sha256": "f784ef3bc7bff2de766ecf2bcbbd2702abaf80af2a24a41323b9509d50875fe5",
+        "sha256_in_prefix": "f784ef3bc7bff2de766ecf2bcbbd2702abaf80af2a24a41323b9509d50875fe5",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-6",
+        "path_type": "hardlink",
+        "sha256": "ddf1fc797fbed220e28e66004074342145e179ecda8faf9a69d66c40d001e1f1",
+        "sha256_in_prefix": "ddf1fc797fbed220e28e66004074342145e179ecda8faf9a69d66c40d001e1f1",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-7",
+        "path_type": "hardlink",
+        "sha256": "0e7b1327735461818b53015bfcbd7953f19b68c17e69c2d5b0fc933724b21fe3",
+        "sha256_in_prefix": "0e7b1327735461818b53015bfcbd7953f19b68c17e69c2d5b0fc933724b21fe3",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-8",
+        "path_type": "hardlink",
+        "sha256": "92f19053038d0c11bb9e1129ff0112738c65e31357897122bf102fd3d9e4aff8",
+        "sha256_in_prefix": "92f19053038d0c11bb9e1129ff0112738c65e31357897122bf102fd3d9e4aff8",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT-9",
+        "path_type": "hardlink",
+        "sha256": "535591146590016f752572bdf606352bd774ac56580d61f30d4477cfbd4b87a6",
+        "sha256_in_prefix": "535591146590016f752572bdf606352bd774ac56580d61f30d4477cfbd4b87a6",
+        "size_in_bytes": 114
+      },
+      {
+        "_path": "share/zoneinfo/Etc/GMT0",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Etc/Greenwich",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Etc/UCT",
+        "path_type": "hardlink",
+        "sha256": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "sha256_in_prefix": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Etc/UTC",
+        "path_type": "hardlink",
+        "sha256": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "sha256_in_prefix": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Etc/Universal",
+        "path_type": "hardlink",
+        "sha256": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "sha256_in_prefix": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Etc/Zulu",
+        "path_type": "hardlink",
+        "sha256": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "sha256_in_prefix": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Amsterdam",
+        "path_type": "hardlink",
+        "sha256": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "sha256_in_prefix": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "size_in_bytes": 1103
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Andorra",
+        "path_type": "hardlink",
+        "sha256": "95eb93c84e2e76e2015f46876ffecf2bf2a5b25a564b24ba7b4492f3884a16b1",
+        "sha256_in_prefix": "95eb93c84e2e76e2015f46876ffecf2bf2a5b25a564b24ba7b4492f3884a16b1",
+        "size_in_bytes": 389
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Astrakhan",
+        "path_type": "hardlink",
+        "sha256": "3f7139503810e20aac322f8a74c016c0e492b6881d70d97dacb31551da452d72",
+        "sha256_in_prefix": "3f7139503810e20aac322f8a74c016c0e492b6881d70d97dacb31551da452d72",
+        "size_in_bytes": 726
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Athens",
+        "path_type": "hardlink",
+        "sha256": "f1fd678b0548e329b38934f6281255e698dfa761ad1ff841f6ccb79606c61345",
+        "sha256_in_prefix": "f1fd678b0548e329b38934f6281255e698dfa761ad1ff841f6ccb79606c61345",
+        "size_in_bytes": 682
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Belfast",
+        "path_type": "hardlink",
+        "sha256": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "sha256_in_prefix": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "size_in_bytes": 1599
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Belgrade",
+        "path_type": "hardlink",
+        "sha256": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "sha256_in_prefix": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "size_in_bytes": 478
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Berlin",
+        "path_type": "hardlink",
+        "sha256": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "sha256_in_prefix": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "size_in_bytes": 705
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Bratislava",
+        "path_type": "hardlink",
+        "sha256": "a6e930e3375cdcb51f7d8a74885aff89fd14b861ebb75cb339d0f91c16c1469a",
+        "sha256_in_prefix": "a6e930e3375cdcb51f7d8a74885aff89fd14b861ebb75cb339d0f91c16c1469a",
+        "size_in_bytes": 723
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Brussels",
+        "path_type": "hardlink",
+        "sha256": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "sha256_in_prefix": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "size_in_bytes": 1103
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Bucharest",
+        "path_type": "hardlink",
+        "sha256": "898ef81fde9a693309be6a80873528488f128d952d3efbf83c61780a5c059ba5",
+        "sha256_in_prefix": "898ef81fde9a693309be6a80873528488f128d952d3efbf83c61780a5c059ba5",
+        "size_in_bytes": 661
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Budapest",
+        "path_type": "hardlink",
+        "sha256": "a8dafebda9680c8d667afb905ea38c90e848713d7de0473338a2228f1ac3315f",
+        "sha256_in_prefix": "a8dafebda9680c8d667afb905ea38c90e848713d7de0473338a2228f1ac3315f",
+        "size_in_bytes": 766
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Busingen",
+        "path_type": "hardlink",
+        "sha256": "199062b1c30cfeb2375ec84c56df52be51891986a6293b7a124d3a62509f45e9",
+        "sha256_in_prefix": "199062b1c30cfeb2375ec84c56df52be51891986a6293b7a124d3a62509f45e9",
+        "size_in_bytes": 497
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Chisinau",
+        "path_type": "hardlink",
+        "sha256": "e533e1902b71c5ad01c8b0afed8c4eadce55b5dba2dafd955fcbeb4a8a4f90fb",
+        "sha256_in_prefix": "e533e1902b71c5ad01c8b0afed8c4eadce55b5dba2dafd955fcbeb4a8a4f90fb",
+        "size_in_bytes": 755
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Copenhagen",
+        "path_type": "hardlink",
+        "sha256": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "sha256_in_prefix": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "size_in_bytes": 705
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Dublin",
+        "path_type": "hardlink",
+        "sha256": "11c00336e02f1318fe764ab29467c5f2afefbfffa644fa8dd24f5b083b495b71",
+        "sha256_in_prefix": "11c00336e02f1318fe764ab29467c5f2afefbfffa644fa8dd24f5b083b495b71",
+        "size_in_bytes": 1496
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Gibraltar",
+        "path_type": "hardlink",
+        "sha256": "b758609434cb50816ab3dd6763996e94dee8c64a005c79e1d338f268a1b66c6f",
+        "sha256_in_prefix": "b758609434cb50816ab3dd6763996e94dee8c64a005c79e1d338f268a1b66c6f",
+        "size_in_bytes": 1220
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Guernsey",
+        "path_type": "hardlink",
+        "sha256": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "sha256_in_prefix": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "size_in_bytes": 1599
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Helsinki",
+        "path_type": "hardlink",
+        "sha256": "71ca4af5998f09990c5e875d350fc3c8e34f280bae6fe14f36d4692face7a563",
+        "sha256_in_prefix": "71ca4af5998f09990c5e875d350fc3c8e34f280bae6fe14f36d4692face7a563",
+        "size_in_bytes": 481
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Isle_of_Man",
+        "path_type": "hardlink",
+        "sha256": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "sha256_in_prefix": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "size_in_bytes": 1599
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Istanbul",
+        "path_type": "hardlink",
+        "sha256": "2a7163b16b94806f69991348e7d0a60c46eb61b1f0305f5f4b83f613db10806f",
+        "sha256_in_prefix": "2a7163b16b94806f69991348e7d0a60c46eb61b1f0305f5f4b83f613db10806f",
+        "size_in_bytes": 1200
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Jersey",
+        "path_type": "hardlink",
+        "sha256": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "sha256_in_prefix": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "size_in_bytes": 1599
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Kaliningrad",
+        "path_type": "hardlink",
+        "sha256": "e7ba2ff46f26db9c35a4f74917cce8156ceae48e94a01315b24d9e1cf7a56c0f",
+        "sha256_in_prefix": "e7ba2ff46f26db9c35a4f74917cce8156ceae48e94a01315b24d9e1cf7a56c0f",
+        "size_in_bytes": 904
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Kiev",
+        "path_type": "hardlink",
+        "sha256": "0589e80ddecebf9d3077898c12975d2be7393df2856ee9926c534763e1e26bf2",
+        "sha256_in_prefix": "0589e80ddecebf9d3077898c12975d2be7393df2856ee9926c534763e1e26bf2",
+        "size_in_bytes": 558
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Kirov",
+        "path_type": "hardlink",
+        "sha256": "2aa5c67086cc193b8ea0a658046fb96e3ee457315b2b218c03df4f034e35e03d",
+        "sha256_in_prefix": "2aa5c67086cc193b8ea0a658046fb96e3ee457315b2b218c03df4f034e35e03d",
+        "size_in_bytes": 735
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Kyiv",
+        "path_type": "hardlink",
+        "sha256": "0589e80ddecebf9d3077898c12975d2be7393df2856ee9926c534763e1e26bf2",
+        "sha256_in_prefix": "0589e80ddecebf9d3077898c12975d2be7393df2856ee9926c534763e1e26bf2",
+        "size_in_bytes": 558
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Lisbon",
+        "path_type": "hardlink",
+        "sha256": "44d2f6cf84737e6a1e0daf914109e94256beca40b40c9a11b7a04e8bddaee4ec",
+        "sha256_in_prefix": "44d2f6cf84737e6a1e0daf914109e94256beca40b40c9a11b7a04e8bddaee4ec",
+        "size_in_bytes": 1463
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Ljubljana",
+        "path_type": "hardlink",
+        "sha256": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "sha256_in_prefix": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "size_in_bytes": 478
+      },
+      {
+        "_path": "share/zoneinfo/Europe/London",
+        "path_type": "hardlink",
+        "sha256": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "sha256_in_prefix": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "size_in_bytes": 1599
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Luxembourg",
+        "path_type": "hardlink",
+        "sha256": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "sha256_in_prefix": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "size_in_bytes": 1103
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Madrid",
+        "path_type": "hardlink",
+        "sha256": "ca5b321ddbfc88e07e0d03ed2fa0c832ce5d0dd8e7d90a25200a8e24898c3b21",
+        "sha256_in_prefix": "ca5b321ddbfc88e07e0d03ed2fa0c832ce5d0dd8e7d90a25200a8e24898c3b21",
+        "size_in_bytes": 897
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Malta",
+        "path_type": "hardlink",
+        "sha256": "8ab5ff9c30fe05760e6da76ebbfbe13ded45df5c6680bdfae1d48e693fce55ca",
+        "sha256_in_prefix": "8ab5ff9c30fe05760e6da76ebbfbe13ded45df5c6680bdfae1d48e693fce55ca",
+        "size_in_bytes": 928
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Mariehamn",
+        "path_type": "hardlink",
+        "sha256": "71ca4af5998f09990c5e875d350fc3c8e34f280bae6fe14f36d4692face7a563",
+        "sha256_in_prefix": "71ca4af5998f09990c5e875d350fc3c8e34f280bae6fe14f36d4692face7a563",
+        "size_in_bytes": 481
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Minsk",
+        "path_type": "hardlink",
+        "sha256": "f3a88fff10ed89d9140aa8e4a0a847e7f125dd5236d5f4a0a0889797f07351a5",
+        "sha256_in_prefix": "f3a88fff10ed89d9140aa8e4a0a847e7f125dd5236d5f4a0a0889797f07351a5",
+        "size_in_bytes": 808
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Monaco",
+        "path_type": "hardlink",
+        "sha256": "cd588e779c5737d70e4e47158dafab7945b026b2bb34454cc47741815459b068",
+        "sha256_in_prefix": "cd588e779c5737d70e4e47158dafab7945b026b2bb34454cc47741815459b068",
+        "size_in_bytes": 1105
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Moscow",
+        "path_type": "hardlink",
+        "sha256": "ed2e0a099fb446b2416683438d3f56f9fc5a62a16c7549a7f59cbc935b364c8a",
+        "sha256_in_prefix": "ed2e0a099fb446b2416683438d3f56f9fc5a62a16c7549a7f59cbc935b364c8a",
+        "size_in_bytes": 908
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Nicosia",
+        "path_type": "hardlink",
+        "sha256": "4d862a5a9f2c2b40300541c0a74c2eba2859b90d7d45776ddbc6ed877df33812",
+        "sha256_in_prefix": "4d862a5a9f2c2b40300541c0a74c2eba2859b90d7d45776ddbc6ed877df33812",
+        "size_in_bytes": 597
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Oslo",
+        "path_type": "hardlink",
+        "sha256": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "sha256_in_prefix": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "size_in_bytes": 705
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Paris",
+        "path_type": "hardlink",
+        "sha256": "cd588e779c5737d70e4e47158dafab7945b026b2bb34454cc47741815459b068",
+        "sha256_in_prefix": "cd588e779c5737d70e4e47158dafab7945b026b2bb34454cc47741815459b068",
+        "size_in_bytes": 1105
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Podgorica",
+        "path_type": "hardlink",
+        "sha256": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "sha256_in_prefix": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "size_in_bytes": 478
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Prague",
+        "path_type": "hardlink",
+        "sha256": "a6e930e3375cdcb51f7d8a74885aff89fd14b861ebb75cb339d0f91c16c1469a",
+        "sha256_in_prefix": "a6e930e3375cdcb51f7d8a74885aff89fd14b861ebb75cb339d0f91c16c1469a",
+        "size_in_bytes": 723
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Riga",
+        "path_type": "hardlink",
+        "sha256": "3d4f1a99ebfef1756f97807f25438e38cd687d231ba2da7edcc3c63c7a4fa13c",
+        "sha256_in_prefix": "3d4f1a99ebfef1756f97807f25438e38cd687d231ba2da7edcc3c63c7a4fa13c",
+        "size_in_bytes": 694
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Rome",
+        "path_type": "hardlink",
+        "sha256": "86bd26a06fe3057b36cf29dd7a338f2524aff8116ef08d005aa2114ea6122869",
+        "sha256_in_prefix": "86bd26a06fe3057b36cf29dd7a338f2524aff8116ef08d005aa2114ea6122869",
+        "size_in_bytes": 947
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Samara",
+        "path_type": "hardlink",
+        "sha256": "55ceb40097bed3e6fca6b362170653512d5b09b5b1c6e1279cd720a7c6244116",
+        "sha256_in_prefix": "55ceb40097bed3e6fca6b362170653512d5b09b5b1c6e1279cd720a7c6244116",
+        "size_in_bytes": 732
+      },
+      {
+        "_path": "share/zoneinfo/Europe/San_Marino",
+        "path_type": "hardlink",
+        "sha256": "86bd26a06fe3057b36cf29dd7a338f2524aff8116ef08d005aa2114ea6122869",
+        "sha256_in_prefix": "86bd26a06fe3057b36cf29dd7a338f2524aff8116ef08d005aa2114ea6122869",
+        "size_in_bytes": 947
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Sarajevo",
+        "path_type": "hardlink",
+        "sha256": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "sha256_in_prefix": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "size_in_bytes": 478
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Saratov",
+        "path_type": "hardlink",
+        "sha256": "d1f3777951557b01be0d2564f71240043401d52fcdca7dfb6c73a38f95fc066d",
+        "sha256_in_prefix": "d1f3777951557b01be0d2564f71240043401d52fcdca7dfb6c73a38f95fc066d",
+        "size_in_bytes": 726
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Simferopol",
+        "path_type": "hardlink",
+        "sha256": "cb63726dff4b19536a35d5bf18f4be3480d12eb8b21ffa72c4aa53d339804cae",
+        "sha256_in_prefix": "cb63726dff4b19536a35d5bf18f4be3480d12eb8b21ffa72c4aa53d339804cae",
+        "size_in_bytes": 865
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Skopje",
+        "path_type": "hardlink",
+        "sha256": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "sha256_in_prefix": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "size_in_bytes": 478
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Sofia",
+        "path_type": "hardlink",
+        "sha256": "2d08c2f8e2642f84f365ca83f895287c3020d7ea89ba2ff6462e84a228b632e4",
+        "sha256_in_prefix": "2d08c2f8e2642f84f365ca83f895287c3020d7ea89ba2ff6462e84a228b632e4",
+        "size_in_bytes": 592
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Stockholm",
+        "path_type": "hardlink",
+        "sha256": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "sha256_in_prefix": "a7fd9932d785d4d690900b834c3563c1810c1cf2e01711bcc0926af6c0767cb7",
+        "size_in_bytes": 705
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Tallinn",
+        "path_type": "hardlink",
+        "sha256": "47ac917cfa8448e61059fb659dc0d6a3f7d06a4eb579e88440ac20fc2f82ed6f",
+        "sha256_in_prefix": "47ac917cfa8448e61059fb659dc0d6a3f7d06a4eb579e88440ac20fc2f82ed6f",
+        "size_in_bytes": 675
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Tirane",
+        "path_type": "hardlink",
+        "sha256": "23e6a501359177c99f4a0be7af774dfc5f6f6d307ae9a96fcf6190a342d46cf7",
+        "sha256_in_prefix": "23e6a501359177c99f4a0be7af774dfc5f6f6d307ae9a96fcf6190a342d46cf7",
+        "size_in_bytes": 604
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Tiraspol",
+        "path_type": "hardlink",
+        "sha256": "e533e1902b71c5ad01c8b0afed8c4eadce55b5dba2dafd955fcbeb4a8a4f90fb",
+        "sha256_in_prefix": "e533e1902b71c5ad01c8b0afed8c4eadce55b5dba2dafd955fcbeb4a8a4f90fb",
+        "size_in_bytes": 755
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Ulyanovsk",
+        "path_type": "hardlink",
+        "sha256": "daf2b45da86d07f74a8c30d771c8cc8db4366c039f2837baeae303aad8f31e6e",
+        "sha256_in_prefix": "daf2b45da86d07f74a8c30d771c8cc8db4366c039f2837baeae303aad8f31e6e",
+        "size_in_bytes": 760
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Uzhgorod",
+        "path_type": "hardlink",
+        "sha256": "0589e80ddecebf9d3077898c12975d2be7393df2856ee9926c534763e1e26bf2",
+        "sha256_in_prefix": "0589e80ddecebf9d3077898c12975d2be7393df2856ee9926c534763e1e26bf2",
+        "size_in_bytes": 558
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Vaduz",
+        "path_type": "hardlink",
+        "sha256": "199062b1c30cfeb2375ec84c56df52be51891986a6293b7a124d3a62509f45e9",
+        "sha256_in_prefix": "199062b1c30cfeb2375ec84c56df52be51891986a6293b7a124d3a62509f45e9",
+        "size_in_bytes": 497
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Vatican",
+        "path_type": "hardlink",
+        "sha256": "86bd26a06fe3057b36cf29dd7a338f2524aff8116ef08d005aa2114ea6122869",
+        "sha256_in_prefix": "86bd26a06fe3057b36cf29dd7a338f2524aff8116ef08d005aa2114ea6122869",
+        "size_in_bytes": 947
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Vienna",
+        "path_type": "hardlink",
+        "sha256": "abcfd4176dfe287a9cd9acb88eed2a4f54ee052a514e7941ee2eaf125938789c",
+        "sha256_in_prefix": "abcfd4176dfe287a9cd9acb88eed2a4f54ee052a514e7941ee2eaf125938789c",
+        "size_in_bytes": 658
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Vilnius",
+        "path_type": "hardlink",
+        "sha256": "857befd4f6909dd6a94fb85dcb03cedfbdfc63766a6d6fe1271f3b921c9a38f3",
+        "sha256_in_prefix": "857befd4f6909dd6a94fb85dcb03cedfbdfc63766a6d6fe1271f3b921c9a38f3",
+        "size_in_bytes": 676
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Volgograd",
+        "path_type": "hardlink",
+        "sha256": "bf73fa88527ead3849a6b54d0f107b6580eb8a6b6c5bb22f422fe026966224e4",
+        "sha256_in_prefix": "bf73fa88527ead3849a6b54d0f107b6580eb8a6b6c5bb22f422fe026966224e4",
+        "size_in_bytes": 753
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Warsaw",
+        "path_type": "hardlink",
+        "sha256": "e88f5a51f168157a41ac2dd8a4ee0e9a879419c84c6122b4771b1a2a33d93a4c",
+        "sha256_in_prefix": "e88f5a51f168157a41ac2dd8a4ee0e9a879419c84c6122b4771b1a2a33d93a4c",
+        "size_in_bytes": 923
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Zagreb",
+        "path_type": "hardlink",
+        "sha256": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "sha256_in_prefix": "a8c964f3eaa7a209d9a650fb16c68c003e9a5fc62ffbbb10fa849d54fb3662d6",
+        "size_in_bytes": 478
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Zaporozhye",
+        "path_type": "hardlink",
+        "sha256": "0589e80ddecebf9d3077898c12975d2be7393df2856ee9926c534763e1e26bf2",
+        "sha256_in_prefix": "0589e80ddecebf9d3077898c12975d2be7393df2856ee9926c534763e1e26bf2",
+        "size_in_bytes": 558
+      },
+      {
+        "_path": "share/zoneinfo/Europe/Zurich",
+        "path_type": "hardlink",
+        "sha256": "199062b1c30cfeb2375ec84c56df52be51891986a6293b7a124d3a62509f45e9",
+        "sha256_in_prefix": "199062b1c30cfeb2375ec84c56df52be51891986a6293b7a124d3a62509f45e9",
+        "size_in_bytes": 497
+      },
+      {
+        "_path": "share/zoneinfo/Factory",
+        "path_type": "hardlink",
+        "sha256": "d32b579ed0a7427316bea260b9ee2675451046bd58c57c679c24f2671860af76",
+        "sha256_in_prefix": "d32b579ed0a7427316bea260b9ee2675451046bd58c57c679c24f2671860af76",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/GB",
+        "path_type": "hardlink",
+        "sha256": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "sha256_in_prefix": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "size_in_bytes": 1599
+      },
+      {
+        "_path": "share/zoneinfo/GB-Eire",
+        "path_type": "hardlink",
+        "sha256": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "sha256_in_prefix": "676541f0b8ad457c744c093f807589adcad909e3fd03f901787d08786eedbd33",
+        "size_in_bytes": 1599
+      },
+      {
+        "_path": "share/zoneinfo/GMT",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/GMT+0",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/GMT-0",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/GMT0",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Greenwich",
+        "path_type": "hardlink",
+        "sha256": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "sha256_in_prefix": "dc4a07571b10884e4f4f3450c9d1a1cbf4c03ef53d06ed2e4ea152d9eba5d5d7",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/HST",
+        "path_type": "hardlink",
+        "sha256": "1daa5729aa1e0f32cd44be112d01ad4cc567a9fe76d87dcbb9182be8d2c88ff0",
+        "sha256_in_prefix": "1daa5729aa1e0f32cd44be112d01ad4cc567a9fe76d87dcbb9182be8d2c88ff0",
+        "size_in_bytes": 221
+      },
+      {
+        "_path": "share/zoneinfo/Hongkong",
+        "path_type": "hardlink",
+        "sha256": "f4068f73246db97417f73467453564c57d6646ce4909b9fa2536923efcd7eb4f",
+        "sha256_in_prefix": "f4068f73246db97417f73467453564c57d6646ce4909b9fa2536923efcd7eb4f",
+        "size_in_bytes": 775
+      },
+      {
+        "_path": "share/zoneinfo/Iceland",
+        "path_type": "hardlink",
+        "sha256": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "sha256_in_prefix": "f3e7fcaa0e9840ff4169d3567d8fb5926644848f4963d7acf92320843c5d486e",
+        "size_in_bytes": 130
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Antananarivo",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Chagos",
+        "path_type": "hardlink",
+        "sha256": "27f692eebb34646d5d3d319ea245f1349a45e0f76cf2ed5cb78f5c46d5fb8226",
+        "sha256_in_prefix": "27f692eebb34646d5d3d319ea245f1349a45e0f76cf2ed5cb78f5c46d5fb8226",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Christmas",
+        "path_type": "hardlink",
+        "sha256": "cdc8e2c282d8bc9a5e9c3caf2fc45ff4e9e5cd18f5dec8cb873340ad7c584d64",
+        "sha256_in_prefix": "cdc8e2c282d8bc9a5e9c3caf2fc45ff4e9e5cd18f5dec8cb873340ad7c584d64",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Cocos",
+        "path_type": "hardlink",
+        "sha256": "e89d835c811d4da44aa8b386782ce8828df085aa0ee8f25661a9881d2f00e90c",
+        "sha256_in_prefix": "e89d835c811d4da44aa8b386782ce8828df085aa0ee8f25661a9881d2f00e90c",
+        "size_in_bytes": 187
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Comoro",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Kerguelen",
+        "path_type": "hardlink",
+        "sha256": "94485f0f58f842767ec2db93539d5fc3afb2bdce16673d9e63c0988cccd6438e",
+        "sha256_in_prefix": "94485f0f58f842767ec2db93539d5fc3afb2bdce16673d9e63c0988cccd6438e",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Mahe",
+        "path_type": "hardlink",
+        "sha256": "0d9ea5053e83188032a6fb4d301d5db688f43011e5b6b1f917a11b71a0da7b16",
+        "sha256_in_prefix": "0d9ea5053e83188032a6fb4d301d5db688f43011e5b6b1f917a11b71a0da7b16",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Maldives",
+        "path_type": "hardlink",
+        "sha256": "94485f0f58f842767ec2db93539d5fc3afb2bdce16673d9e63c0988cccd6438e",
+        "sha256_in_prefix": "94485f0f58f842767ec2db93539d5fc3afb2bdce16673d9e63c0988cccd6438e",
+        "size_in_bytes": 152
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Mauritius",
+        "path_type": "hardlink",
+        "sha256": "47aa5d25a96b1d52b92e518e984b320faebff9ce5af69b4933ec44ef5168f214",
+        "sha256_in_prefix": "47aa5d25a96b1d52b92e518e984b320faebff9ce5af69b4933ec44ef5168f214",
+        "size_in_bytes": 179
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Mayotte",
+        "path_type": "hardlink",
+        "sha256": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "sha256_in_prefix": "0783854f52c33ada6b6d2a5d867662f0ae8e15238d2fce7b9ada4f4d319eb466",
+        "size_in_bytes": 191
+      },
+      {
+        "_path": "share/zoneinfo/Indian/Reunion",
+        "path_type": "hardlink",
+        "sha256": "0d9ea5053e83188032a6fb4d301d5db688f43011e5b6b1f917a11b71a0da7b16",
+        "sha256_in_prefix": "0d9ea5053e83188032a6fb4d301d5db688f43011e5b6b1f917a11b71a0da7b16",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Iran",
+        "path_type": "hardlink",
+        "sha256": "a332e584d5f3a49099c7b6dcf95a5c98d76076d9fa94fb45e9ff6a91a0c4c9c2",
+        "sha256_in_prefix": "a332e584d5f3a49099c7b6dcf95a5c98d76076d9fa94fb45e9ff6a91a0c4c9c2",
+        "size_in_bytes": 812
+      },
+      {
+        "_path": "share/zoneinfo/Israel",
+        "path_type": "hardlink",
+        "sha256": "9fcde8d584dea0585f5c8727aaf35f48a149e0dbd3a83bf6cef8bca9c14021e3",
+        "sha256_in_prefix": "9fcde8d584dea0585f5c8727aaf35f48a149e0dbd3a83bf6cef8bca9c14021e3",
+        "size_in_bytes": 1074
+      },
+      {
+        "_path": "share/zoneinfo/Jamaica",
+        "path_type": "hardlink",
+        "sha256": "a437b1700333aeff53a8b5868d5387c080dc14c2d3e95aa5ce36f901b3669284",
+        "sha256_in_prefix": "a437b1700333aeff53a8b5868d5387c080dc14c2d3e95aa5ce36f901b3669284",
+        "size_in_bytes": 339
+      },
+      {
+        "_path": "share/zoneinfo/Japan",
+        "path_type": "hardlink",
+        "sha256": "59a3871430f0d3b93e619fa30a43a41d1e88bdd49ff26f09d0f405a500706f96",
+        "sha256_in_prefix": "59a3871430f0d3b93e619fa30a43a41d1e88bdd49ff26f09d0f405a500706f96",
+        "size_in_bytes": 213
+      },
+      {
+        "_path": "share/zoneinfo/Kwajalein",
+        "path_type": "hardlink",
+        "sha256": "4be6458ba89d2b30da7a52f2ec346318f783d2cee856e777c4b33164a365064f",
+        "sha256_in_prefix": "4be6458ba89d2b30da7a52f2ec346318f783d2cee856e777c4b33164a365064f",
+        "size_in_bytes": 219
+      },
+      {
+        "_path": "share/zoneinfo/Libya",
+        "path_type": "hardlink",
+        "sha256": "cf33012d9661e15438fc045ee64e0bfebb2ea8a3fb79d2af56df05ea4be3e453",
+        "sha256_in_prefix": "cf33012d9661e15438fc045ee64e0bfebb2ea8a3fb79d2af56df05ea4be3e453",
+        "size_in_bytes": 431
+      },
+      {
+        "_path": "share/zoneinfo/MET",
+        "path_type": "hardlink",
+        "sha256": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "sha256_in_prefix": "b10f9542a8509f0a63ebca78e3d80432dd86b8ea296400280febd9cfa76e8288",
+        "size_in_bytes": 1103
+      },
+      {
+        "_path": "share/zoneinfo/MST",
+        "path_type": "hardlink",
+        "sha256": "ae11453c21d08984de75f2efec04dc93178a7b4e23c5e52f2098b8bd45ccb547",
+        "sha256_in_prefix": "ae11453c21d08984de75f2efec04dc93178a7b4e23c5e52f2098b8bd45ccb547",
+        "size_in_bytes": 240
+      },
+      {
+        "_path": "share/zoneinfo/MST7MDT",
+        "path_type": "hardlink",
+        "sha256": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "sha256_in_prefix": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "size_in_bytes": 1042
+      },
+      {
+        "_path": "share/zoneinfo/Mexico/BajaNorte",
+        "path_type": "hardlink",
+        "sha256": "3065abfbab680d16ab8cc5d36a23885a004558d6f0ee51ef89d2ee3ca1717c8a",
+        "sha256_in_prefix": "3065abfbab680d16ab8cc5d36a23885a004558d6f0ee51ef89d2ee3ca1717c8a",
+        "size_in_bytes": 1079
+      },
+      {
+        "_path": "share/zoneinfo/Mexico/BajaSur",
+        "path_type": "hardlink",
+        "sha256": "20dede710f520eaf6c0cdbeefe773fc6e30dd8b1d28aaf17e9842099551ee9a6",
+        "sha256_in_prefix": "20dede710f520eaf6c0cdbeefe773fc6e30dd8b1d28aaf17e9842099551ee9a6",
+        "size_in_bytes": 690
+      },
+      {
+        "_path": "share/zoneinfo/Mexico/General",
+        "path_type": "hardlink",
+        "sha256": "37dd2bf08f13fce0f707c3b1f4cec4018efbd9c47c8367b0fb4debbd461bd72f",
+        "sha256_in_prefix": "37dd2bf08f13fce0f707c3b1f4cec4018efbd9c47c8367b0fb4debbd461bd72f",
+        "size_in_bytes": 773
+      },
+      {
+        "_path": "share/zoneinfo/NZ",
+        "path_type": "hardlink",
+        "sha256": "0e06e7e55aedbc92ef5b3d106e7c392ab1628cfd8a428b20e92e99028a0bfbb9",
+        "sha256_in_prefix": "0e06e7e55aedbc92ef5b3d106e7c392ab1628cfd8a428b20e92e99028a0bfbb9",
+        "size_in_bytes": 1043
+      },
+      {
+        "_path": "share/zoneinfo/NZ-CHAT",
+        "path_type": "hardlink",
+        "sha256": "a67858fcb6fc5787a8e9c2b7c8be8964bd3ce9223f7ad1baac2c9ca6925f4c78",
+        "sha256_in_prefix": "a67858fcb6fc5787a8e9c2b7c8be8964bd3ce9223f7ad1baac2c9ca6925f4c78",
+        "size_in_bytes": 808
+      },
+      {
+        "_path": "share/zoneinfo/Navajo",
+        "path_type": "hardlink",
+        "sha256": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "sha256_in_prefix": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "size_in_bytes": 1042
+      },
+      {
+        "_path": "share/zoneinfo/PRC",
+        "path_type": "hardlink",
+        "sha256": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "sha256_in_prefix": "bf8b7ed82fe6e63e6d98f8cea934eeac901cd16aba85eb5755ce3f8b4289ea8a",
+        "size_in_bytes": 393
+      },
+      {
+        "_path": "share/zoneinfo/PST8PDT",
+        "path_type": "hardlink",
+        "sha256": "200d05754f6d83a371cf408d7085125797657b3b0bebeba1e508cffe86a3e5c8",
+        "sha256_in_prefix": "200d05754f6d83a371cf408d7085125797657b3b0bebeba1e508cffe86a3e5c8",
+        "size_in_bytes": 1294
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Apia",
+        "path_type": "hardlink",
+        "sha256": "dc70c47c80ab2c87a1ab754bab8febfc38508059e249dfe55e73a3759808ea14",
+        "sha256_in_prefix": "dc70c47c80ab2c87a1ab754bab8febfc38508059e249dfe55e73a3759808ea14",
+        "size_in_bytes": 407
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Auckland",
+        "path_type": "hardlink",
+        "sha256": "0e06e7e55aedbc92ef5b3d106e7c392ab1628cfd8a428b20e92e99028a0bfbb9",
+        "sha256_in_prefix": "0e06e7e55aedbc92ef5b3d106e7c392ab1628cfd8a428b20e92e99028a0bfbb9",
+        "size_in_bytes": 1043
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Bougainville",
+        "path_type": "hardlink",
+        "sha256": "aea767d58e0749aaf1faf8cf934d25b0735f863dc842028256202cba6b8dfc86",
+        "sha256_in_prefix": "aea767d58e0749aaf1faf8cf934d25b0735f863dc842028256202cba6b8dfc86",
+        "size_in_bytes": 201
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Chatham",
+        "path_type": "hardlink",
+        "sha256": "a67858fcb6fc5787a8e9c2b7c8be8964bd3ce9223f7ad1baac2c9ca6925f4c78",
+        "sha256_in_prefix": "a67858fcb6fc5787a8e9c2b7c8be8964bd3ce9223f7ad1baac2c9ca6925f4c78",
+        "size_in_bytes": 808
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Chuuk",
+        "path_type": "hardlink",
+        "sha256": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "sha256_in_prefix": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Easter",
+        "path_type": "hardlink",
+        "sha256": "13054cef85e3b1ba0f5712bd6d699d7789d3aedbdab0fd7394b771acc07f61a1",
+        "sha256_in_prefix": "13054cef85e3b1ba0f5712bd6d699d7789d3aedbdab0fd7394b771acc07f61a1",
+        "size_in_bytes": 1174
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Efate",
+        "path_type": "hardlink",
+        "sha256": "2e25ffad37e2a5087f567a9bfe6ece1b1c81b720140bd5003552875292e809c5",
+        "sha256_in_prefix": "2e25ffad37e2a5087f567a9bfe6ece1b1c81b720140bd5003552875292e809c5",
+        "size_in_bytes": 342
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Enderbury",
+        "path_type": "hardlink",
+        "sha256": "a23386fa8aa2db91ce9d8e811616afff76e65a0d4b0c82d3e2ffa4c4e155baa2",
+        "sha256_in_prefix": "a23386fa8aa2db91ce9d8e811616afff76e65a0d4b0c82d3e2ffa4c4e155baa2",
+        "size_in_bytes": 172
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Fakaofo",
+        "path_type": "hardlink",
+        "sha256": "51ff3378c2f65fc7683e0f025fea7498c18ff883a3eda1c031eed42c3e648710",
+        "sha256_in_prefix": "51ff3378c2f65fc7683e0f025fea7498c18ff883a3eda1c031eed42c3e648710",
+        "size_in_bytes": 153
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Fiji",
+        "path_type": "hardlink",
+        "sha256": "ba608d86d4ee0738935e77be580c73bd8bc62aa6714d8393c0afad261621e0c4",
+        "sha256_in_prefix": "ba608d86d4ee0738935e77be580c73bd8bc62aa6714d8393c0afad261621e0c4",
+        "size_in_bytes": 396
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Funafuti",
+        "path_type": "hardlink",
+        "sha256": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "sha256_in_prefix": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "size_in_bytes": 134
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Galapagos",
+        "path_type": "hardlink",
+        "sha256": "6752893d94af3bc33f3dacbd58b70d031ce3a3c8a63eb43b1675cd3977d997c7",
+        "sha256_in_prefix": "6752893d94af3bc33f3dacbd58b70d031ce3a3c8a63eb43b1675cd3977d997c7",
+        "size_in_bytes": 175
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Gambier",
+        "path_type": "hardlink",
+        "sha256": "c8887cea18e90e4d704564d525138e1aa9fdb6473b7bdfceeb3371aacfb00683",
+        "sha256_in_prefix": "c8887cea18e90e4d704564d525138e1aa9fdb6473b7bdfceeb3371aacfb00683",
+        "size_in_bytes": 132
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Guadalcanal",
+        "path_type": "hardlink",
+        "sha256": "522f0f374b61e2c6f5fa7d19f1c7acccd09e4a213462ee3b42c90d32bf2bf18c",
+        "sha256_in_prefix": "522f0f374b61e2c6f5fa7d19f1c7acccd09e4a213462ee3b42c90d32bf2bf18c",
+        "size_in_bytes": 134
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Guam",
+        "path_type": "hardlink",
+        "sha256": "8b9ede33ab32ae2505bc06eb5402e7ce20b0fc8e2510dcb305c25d39a1fbd725",
+        "sha256_in_prefix": "8b9ede33ab32ae2505bc06eb5402e7ce20b0fc8e2510dcb305c25d39a1fbd725",
+        "size_in_bytes": 350
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Honolulu",
+        "path_type": "hardlink",
+        "sha256": "1daa5729aa1e0f32cd44be112d01ad4cc567a9fe76d87dcbb9182be8d2c88ff0",
+        "sha256_in_prefix": "1daa5729aa1e0f32cd44be112d01ad4cc567a9fe76d87dcbb9182be8d2c88ff0",
+        "size_in_bytes": 221
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Johnston",
+        "path_type": "hardlink",
+        "sha256": "1daa5729aa1e0f32cd44be112d01ad4cc567a9fe76d87dcbb9182be8d2c88ff0",
+        "sha256_in_prefix": "1daa5729aa1e0f32cd44be112d01ad4cc567a9fe76d87dcbb9182be8d2c88ff0",
+        "size_in_bytes": 221
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Kanton",
+        "path_type": "hardlink",
+        "sha256": "a23386fa8aa2db91ce9d8e811616afff76e65a0d4b0c82d3e2ffa4c4e155baa2",
+        "sha256_in_prefix": "a23386fa8aa2db91ce9d8e811616afff76e65a0d4b0c82d3e2ffa4c4e155baa2",
+        "size_in_bytes": 172
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Kiritimati",
+        "path_type": "hardlink",
+        "sha256": "71454698c44182595fb982775f4074ce0d017fe2cfa3d97b2dee63bbcf36771e",
+        "sha256_in_prefix": "71454698c44182595fb982775f4074ce0d017fe2cfa3d97b2dee63bbcf36771e",
+        "size_in_bytes": 174
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Kosrae",
+        "path_type": "hardlink",
+        "sha256": "a5030b2578a5ca03e19649b48c2a3926e566a6660980b21d89357178fe7d6448",
+        "sha256_in_prefix": "a5030b2578a5ca03e19649b48c2a3926e566a6660980b21d89357178fe7d6448",
+        "size_in_bytes": 242
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Kwajalein",
+        "path_type": "hardlink",
+        "sha256": "4be6458ba89d2b30da7a52f2ec346318f783d2cee856e777c4b33164a365064f",
+        "sha256_in_prefix": "4be6458ba89d2b30da7a52f2ec346318f783d2cee856e777c4b33164a365064f",
+        "size_in_bytes": 219
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Majuro",
+        "path_type": "hardlink",
+        "sha256": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "sha256_in_prefix": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "size_in_bytes": 134
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Marquesas",
+        "path_type": "hardlink",
+        "sha256": "8a5a6b911be7f8dd578e9b5223fd19c148deba890ffb997ae2e2a3441a74931c",
+        "sha256_in_prefix": "8a5a6b911be7f8dd578e9b5223fd19c148deba890ffb997ae2e2a3441a74931c",
+        "size_in_bytes": 139
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Midway",
+        "path_type": "hardlink",
+        "sha256": "650d918751366590553063cd681592fdca8a09957e0ce2c18d6697ec385ef796",
+        "sha256_in_prefix": "650d918751366590553063cd681592fdca8a09957e0ce2c18d6697ec385ef796",
+        "size_in_bytes": 146
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Nauru",
+        "path_type": "hardlink",
+        "sha256": "c1a85938d8eb78d026630850d8259d28c004dd2566e12d9a62f319a9c0254987",
+        "sha256_in_prefix": "c1a85938d8eb78d026630850d8259d28c004dd2566e12d9a62f319a9c0254987",
+        "size_in_bytes": 183
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Niue",
+        "path_type": "hardlink",
+        "sha256": "f1659e6ed8029eb3012a3b8b3446045a592d348da8a769242a093455ccfc19a3",
+        "sha256_in_prefix": "f1659e6ed8029eb3012a3b8b3446045a592d348da8a769242a093455ccfc19a3",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Norfolk",
+        "path_type": "hardlink",
+        "sha256": "bcbf06e96e4249c62aa7bea0d1bd7950f2181f0d8bb7ad2a3a4b47505edc683b",
+        "sha256_in_prefix": "bcbf06e96e4249c62aa7bea0d1bd7950f2181f0d8bb7ad2a3a4b47505edc683b",
+        "size_in_bytes": 237
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Noumea",
+        "path_type": "hardlink",
+        "sha256": "7b35329fb0185816e5ad96d2b6522d258bbb5c83422e28a1ac205907e065f90c",
+        "sha256_in_prefix": "7b35329fb0185816e5ad96d2b6522d258bbb5c83422e28a1ac205907e065f90c",
+        "size_in_bytes": 198
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Pago_Pago",
+        "path_type": "hardlink",
+        "sha256": "650d918751366590553063cd681592fdca8a09957e0ce2c18d6697ec385ef796",
+        "sha256_in_prefix": "650d918751366590553063cd681592fdca8a09957e0ce2c18d6697ec385ef796",
+        "size_in_bytes": 146
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Palau",
+        "path_type": "hardlink",
+        "sha256": "5642d1b0a514557a37ceb8405e7f6233ea4ac926c62157f35a8a290e199c78c0",
+        "sha256_in_prefix": "5642d1b0a514557a37ceb8405e7f6233ea4ac926c62157f35a8a290e199c78c0",
+        "size_in_bytes": 148
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Pitcairn",
+        "path_type": "hardlink",
+        "sha256": "00987aa252715d0cc231628e139c9ee231df820d5503ef7e80267931bad7ffc1",
+        "sha256_in_prefix": "00987aa252715d0cc231628e139c9ee231df820d5503ef7e80267931bad7ffc1",
+        "size_in_bytes": 153
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Pohnpei",
+        "path_type": "hardlink",
+        "sha256": "522f0f374b61e2c6f5fa7d19f1c7acccd09e4a213462ee3b42c90d32bf2bf18c",
+        "sha256_in_prefix": "522f0f374b61e2c6f5fa7d19f1c7acccd09e4a213462ee3b42c90d32bf2bf18c",
+        "size_in_bytes": 134
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Ponape",
+        "path_type": "hardlink",
+        "sha256": "522f0f374b61e2c6f5fa7d19f1c7acccd09e4a213462ee3b42c90d32bf2bf18c",
+        "sha256_in_prefix": "522f0f374b61e2c6f5fa7d19f1c7acccd09e4a213462ee3b42c90d32bf2bf18c",
+        "size_in_bytes": 134
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Port_Moresby",
+        "path_type": "hardlink",
+        "sha256": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "sha256_in_prefix": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Rarotonga",
+        "path_type": "hardlink",
+        "sha256": "27a6b698ead3a786ec64da2f8f71e324af40549f3d3e1744a5030c543fff8b5f",
+        "sha256_in_prefix": "27a6b698ead3a786ec64da2f8f71e324af40549f3d3e1744a5030c543fff8b5f",
+        "size_in_bytes": 406
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Saipan",
+        "path_type": "hardlink",
+        "sha256": "8b9ede33ab32ae2505bc06eb5402e7ce20b0fc8e2510dcb305c25d39a1fbd725",
+        "sha256_in_prefix": "8b9ede33ab32ae2505bc06eb5402e7ce20b0fc8e2510dcb305c25d39a1fbd725",
+        "size_in_bytes": 350
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Samoa",
+        "path_type": "hardlink",
+        "sha256": "650d918751366590553063cd681592fdca8a09957e0ce2c18d6697ec385ef796",
+        "sha256_in_prefix": "650d918751366590553063cd681592fdca8a09957e0ce2c18d6697ec385ef796",
+        "size_in_bytes": 146
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Tahiti",
+        "path_type": "hardlink",
+        "sha256": "22f72cd3886d8711108f523fe9a00273bd01cb4966c65be180615887ce377b5e",
+        "sha256_in_prefix": "22f72cd3886d8711108f523fe9a00273bd01cb4966c65be180615887ce377b5e",
+        "size_in_bytes": 133
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Tarawa",
+        "path_type": "hardlink",
+        "sha256": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "sha256_in_prefix": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "size_in_bytes": 134
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Tongatapu",
+        "path_type": "hardlink",
+        "sha256": "9a31a33525004dfc34c8b181d33b0bc73dff2f5b96c4f00d30bf0ae0741020c6",
+        "sha256_in_prefix": "9a31a33525004dfc34c8b181d33b0bc73dff2f5b96c4f00d30bf0ae0741020c6",
+        "size_in_bytes": 237
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Truk",
+        "path_type": "hardlink",
+        "sha256": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "sha256_in_prefix": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Wake",
+        "path_type": "hardlink",
+        "sha256": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "sha256_in_prefix": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "size_in_bytes": 134
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Wallis",
+        "path_type": "hardlink",
+        "sha256": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "sha256_in_prefix": "09035620bd831697a3e9072f82de34cfca5e912d50c8da547739aa2f28fb6d8e",
+        "size_in_bytes": 134
+      },
+      {
+        "_path": "share/zoneinfo/Pacific/Yap",
+        "path_type": "hardlink",
+        "sha256": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "sha256_in_prefix": "683001055b6ef9dc9d88734e0eddd1782f1c3643b7c13a75e9cf8e9052006e19",
+        "size_in_bytes": 154
+      },
+      {
+        "_path": "share/zoneinfo/Poland",
+        "path_type": "hardlink",
+        "sha256": "e88f5a51f168157a41ac2dd8a4ee0e9a879419c84c6122b4771b1a2a33d93a4c",
+        "sha256_in_prefix": "e88f5a51f168157a41ac2dd8a4ee0e9a879419c84c6122b4771b1a2a33d93a4c",
+        "size_in_bytes": 923
+      },
+      {
+        "_path": "share/zoneinfo/Portugal",
+        "path_type": "hardlink",
+        "sha256": "44d2f6cf84737e6a1e0daf914109e94256beca40b40c9a11b7a04e8bddaee4ec",
+        "sha256_in_prefix": "44d2f6cf84737e6a1e0daf914109e94256beca40b40c9a11b7a04e8bddaee4ec",
+        "size_in_bytes": 1463
+      },
+      {
+        "_path": "share/zoneinfo/ROC",
+        "path_type": "hardlink",
+        "sha256": "a04c2c72f4f76a83178d036dd97d157ee1f32e478e44dda7a5c10923687ee6cf",
+        "sha256_in_prefix": "a04c2c72f4f76a83178d036dd97d157ee1f32e478e44dda7a5c10923687ee6cf",
+        "size_in_bytes": 511
+      },
+      {
+        "_path": "share/zoneinfo/ROK",
+        "path_type": "hardlink",
+        "sha256": "64a70b6fbcc9b65e762dbd25eb89b6f40c137146edc8dbd4d081eafacdab78de",
+        "sha256_in_prefix": "64a70b6fbcc9b65e762dbd25eb89b6f40c137146edc8dbd4d081eafacdab78de",
+        "size_in_bytes": 415
+      },
+      {
+        "_path": "share/zoneinfo/Singapore",
+        "path_type": "hardlink",
+        "sha256": "0954b2d9a301d94f4348024606a71bbcb2fa24d3cd3709f5bc8bca605039785d",
+        "sha256_in_prefix": "0954b2d9a301d94f4348024606a71bbcb2fa24d3cd3709f5bc8bca605039785d",
+        "size_in_bytes": 256
+      },
+      {
+        "_path": "share/zoneinfo/Turkey",
+        "path_type": "hardlink",
+        "sha256": "2a7163b16b94806f69991348e7d0a60c46eb61b1f0305f5f4b83f613db10806f",
+        "sha256_in_prefix": "2a7163b16b94806f69991348e7d0a60c46eb61b1f0305f5f4b83f613db10806f",
+        "size_in_bytes": 1200
+      },
+      {
+        "_path": "share/zoneinfo/UCT",
+        "path_type": "hardlink",
+        "sha256": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "sha256_in_prefix": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/US/Alaska",
+        "path_type": "hardlink",
+        "sha256": "77ca0c22962f06998bce5e48d81cb865a14466c83ff5dc607eaa483344058bf6",
+        "sha256_in_prefix": "77ca0c22962f06998bce5e48d81cb865a14466c83ff5dc607eaa483344058bf6",
+        "size_in_bytes": 977
+      },
+      {
+        "_path": "share/zoneinfo/US/Aleutian",
+        "path_type": "hardlink",
+        "sha256": "abfb1980e20d5f84ec5fd881c7580d77a5c6c019f30a383aaa97404212b489e0",
+        "sha256_in_prefix": "abfb1980e20d5f84ec5fd881c7580d77a5c6c019f30a383aaa97404212b489e0",
+        "size_in_bytes": 969
+      },
+      {
+        "_path": "share/zoneinfo/US/Arizona",
+        "path_type": "hardlink",
+        "sha256": "ae11453c21d08984de75f2efec04dc93178a7b4e23c5e52f2098b8bd45ccb547",
+        "sha256_in_prefix": "ae11453c21d08984de75f2efec04dc93178a7b4e23c5e52f2098b8bd45ccb547",
+        "size_in_bytes": 240
+      },
+      {
+        "_path": "share/zoneinfo/US/Central",
+        "path_type": "hardlink",
+        "sha256": "c27b739ff46a7df0594e120d725b439217e11e44ea9a50cdc49130383b5482e7",
+        "sha256_in_prefix": "c27b739ff46a7df0594e120d725b439217e11e44ea9a50cdc49130383b5482e7",
+        "size_in_bytes": 1754
+      },
+      {
+        "_path": "share/zoneinfo/US/East-Indiana",
+        "path_type": "hardlink",
+        "sha256": "e678f42a13efbd7be0f26a9ce53e04b1c28a582eab05611cb01c16836432f07b",
+        "sha256_in_prefix": "e678f42a13efbd7be0f26a9ce53e04b1c28a582eab05611cb01c16836432f07b",
+        "size_in_bytes": 531
+      },
+      {
+        "_path": "share/zoneinfo/US/Eastern",
+        "path_type": "hardlink",
+        "sha256": "d7f2206b3a45989fc9ad63d558922532fa7352280d5f87176bf1db79cb1d1fa9",
+        "sha256_in_prefix": "d7f2206b3a45989fc9ad63d558922532fa7352280d5f87176bf1db79cb1d1fa9",
+        "size_in_bytes": 1744
+      },
+      {
+        "_path": "share/zoneinfo/US/Hawaii",
+        "path_type": "hardlink",
+        "sha256": "1daa5729aa1e0f32cd44be112d01ad4cc567a9fe76d87dcbb9182be8d2c88ff0",
+        "sha256_in_prefix": "1daa5729aa1e0f32cd44be112d01ad4cc567a9fe76d87dcbb9182be8d2c88ff0",
+        "size_in_bytes": 221
+      },
+      {
+        "_path": "share/zoneinfo/US/Indiana-Starke",
+        "path_type": "hardlink",
+        "sha256": "2890b35dcb7c093308b552d82d8781a8ce9a4fa6f9de058283a6836ec1f9f282",
+        "sha256_in_prefix": "2890b35dcb7c093308b552d82d8781a8ce9a4fa6f9de058283a6836ec1f9f282",
+        "size_in_bytes": 1016
+      },
+      {
+        "_path": "share/zoneinfo/US/Michigan",
+        "path_type": "hardlink",
+        "sha256": "23817c32df67c77f0017a0feb2d798b2405afc71ceea3294d7e5b4c9116be740",
+        "sha256_in_prefix": "23817c32df67c77f0017a0feb2d798b2405afc71ceea3294d7e5b4c9116be740",
+        "size_in_bytes": 899
+      },
+      {
+        "_path": "share/zoneinfo/US/Mountain",
+        "path_type": "hardlink",
+        "sha256": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "sha256_in_prefix": "9bb703920eca4b6119e81a105583a4f6ca220651f13b418479ab7cd56c413f3e",
+        "size_in_bytes": 1042
+      },
+      {
+        "_path": "share/zoneinfo/US/Pacific",
+        "path_type": "hardlink",
+        "sha256": "200d05754f6d83a371cf408d7085125797657b3b0bebeba1e508cffe86a3e5c8",
+        "sha256_in_prefix": "200d05754f6d83a371cf408d7085125797657b3b0bebeba1e508cffe86a3e5c8",
+        "size_in_bytes": 1294
+      },
+      {
+        "_path": "share/zoneinfo/US/Samoa",
+        "path_type": "hardlink",
+        "sha256": "650d918751366590553063cd681592fdca8a09957e0ce2c18d6697ec385ef796",
+        "sha256_in_prefix": "650d918751366590553063cd681592fdca8a09957e0ce2c18d6697ec385ef796",
+        "size_in_bytes": 146
+      },
+      {
+        "_path": "share/zoneinfo/UTC",
+        "path_type": "hardlink",
+        "sha256": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "sha256_in_prefix": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/Universal",
+        "path_type": "hardlink",
+        "sha256": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "sha256_in_prefix": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/W-SU",
+        "path_type": "hardlink",
+        "sha256": "ed2e0a099fb446b2416683438d3f56f9fc5a62a16c7549a7f59cbc935b364c8a",
+        "sha256_in_prefix": "ed2e0a099fb446b2416683438d3f56f9fc5a62a16c7549a7f59cbc935b364c8a",
+        "size_in_bytes": 908
+      },
+      {
+        "_path": "share/zoneinfo/WET",
+        "path_type": "hardlink",
+        "sha256": "44d2f6cf84737e6a1e0daf914109e94256beca40b40c9a11b7a04e8bddaee4ec",
+        "sha256_in_prefix": "44d2f6cf84737e6a1e0daf914109e94256beca40b40c9a11b7a04e8bddaee4ec",
+        "size_in_bytes": 1463
+      },
+      {
+        "_path": "share/zoneinfo/Zulu",
+        "path_type": "hardlink",
+        "sha256": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "sha256_in_prefix": "fddce1e648a1732ac29afd9a16151b2973cdf082e7ec0c690f7e42be6b598b93",
+        "size_in_bytes": 111
+      },
+      {
+        "_path": "share/zoneinfo/build/etc/localtime",
+        "path_type": "hardlink",
+        "sha256": "d32b579ed0a7427316bea260b9ee2675451046bd58c57c679c24f2671860af76",
+        "sha256_in_prefix": "d32b579ed0a7427316bea260b9ee2675451046bd58c57c679c24f2671860af76",
+        "size_in_bytes": 113
+      },
+      {
+        "_path": "share/zoneinfo/iso3166.tab",
+        "path_type": "hardlink",
+        "sha256": "a01a5d158f31d46ad8e6f8cc2a06c641810682a9397d460320f68d5421b65e71",
+        "sha256_in_prefix": "a01a5d158f31d46ad8e6f8cc2a06c641810682a9397d460320f68d5421b65e71",
+        "size_in_bytes": 4791
+      },
+      {
+        "_path": "share/zoneinfo/leap-seconds.list",
+        "path_type": "hardlink",
+        "sha256": "0bd731802f83a7ffbb3a7cd17f87af670032e16ad71b14747b057ca655277c25",
+        "sha256_in_prefix": "0bd731802f83a7ffbb3a7cd17f87af670032e16ad71b14747b057ca655277c25",
+        "size_in_bytes": 5069
+      },
+      {
+        "_path": "share/zoneinfo/leapseconds",
+        "path_type": "hardlink",
+        "sha256": "816033c11b84465a03e800c5e55ead515dba53fa159b9c61da7602ea357060e8",
+        "sha256_in_prefix": "816033c11b84465a03e800c5e55ead515dba53fa159b9c61da7602ea357060e8",
+        "size_in_bytes": 3257
+      },
+      {
+        "_path": "share/zoneinfo/tzdata.zi",
+        "path_type": "hardlink",
+        "sha256": "0eeaf8ae352a62a97ea6ecbc0b56de5ead3ddd42225a81edec790b11468a6610",
+        "sha256_in_prefix": "0eeaf8ae352a62a97ea6ecbc0b56de5ead3ddd42225a81edec790b11468a6610",
+        "size_in_bytes": 107170
+      },
+      {
+        "_path": "share/zoneinfo/zone.tab",
+        "path_type": "hardlink",
+        "sha256": "c5ac6f51a11330575ad71034626adc309a91e9c2f2cfda3c30a4814b8aa0e7fe",
+        "sha256_in_prefix": "c5ac6f51a11330575ad71034626adc309a91e9c2f2cfda3c30a4814b8aa0e7fe",
+        "size_in_bytes": 18779
+      },
+      {
+        "_path": "share/zoneinfo/zone1970.tab",
+        "path_type": "hardlink",
+        "sha256": "9e7e19e846a2221d367af8c4f5015ee3b2185e06cc23c18ee45149d23093d1dd",
+        "sha256_in_prefix": "9e7e19e846a2221d367af8c4f5015ee3b2185e06cc23c18ee45149d23093d1dd",
+        "size_in_bytes": 17553
+      },
+      {
+        "_path": "share/zoneinfo/zonenow.tab",
+        "path_type": "hardlink",
+        "sha256": "dbad11daf6a9ddd4696dc139632adbc1de30f73dbac338939e8b03cd1db3023c",
+        "sha256_in_prefix": "dbad11daf6a9ddd4696dc139632adbc1de30f73dbac338939e8b03cd1db3023c",
+        "size_in_bytes": 8071
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "087a1fc45e39ce10930b430bbc54dbc5f6fd00c363c387e2c68a71ae67573668",
+  "size": 120195,
+  "subdir": "noarch",
+  "timestamp": 1737549203664,
+  "track_features": "",
+  "url": "https://repo.anaconda.com/pkgs/main/noarch/tzdata-2025a-h04d1e81_0.conda",
+  "version": "2025a"
+}
\ No newline at end of file
diff --git a/marketing/conda-meta/vc-14.42-haa95532_4.json b/marketing/conda-meta/vc-14.42-haa95532_4.json
new file mode 100644
index 0000000000000000000000000000000000000000..cdd44f900e2df3ccafb173b3e60088d663ceeb3d
--- /dev/null
+++ b/marketing/conda-meta/vc-14.42-haa95532_4.json
@@ -0,0 +1,37 @@
+{
+  "build": "haa95532_4",
+  "build_number": 4,
+  "channel": "https://repo.anaconda.com/pkgs/main/win-64",
+  "constrains": [],
+  "depends": [
+    "vs2015_runtime >=14.42.34433"
+  ],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\vc-14.42-haa95532_4",
+  "features": "",
+  "files": [
+    ".nonadmin"
+  ],
+  "fn": "vc-14.42-haa95532_4.conda",
+  "legacy_bz2_md5": "9ade3f0dfabff28bb61973afd2b50e13",
+  "license": "BSD-3-Clause",
+  "license_family": "BSD",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\vc-14.42-haa95532_4",
+    "type": 1
+  },
+  "md5": "3a087fe8b4809313b355b19c782fb502",
+  "name": "vc",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\vc-14.42-haa95532_4.conda",
+  "paths_data": {
+    "paths": [],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "4ba82ce6a81e8037b9a1887d62beb381e41e0ae0354894171e3351a4382092b1",
+  "size": 10872,
+  "subdir": "win-64",
+  "timestamp": 1739202647759,
+  "track_features": "vc14",
+  "url": "https://repo.anaconda.com/pkgs/main/win-64/vc-14.42-haa95532_4.conda",
+  "version": "14.42"
+}
\ No newline at end of file
diff --git a/marketing/conda-meta/vs2015_runtime-14.42.34433-he0abc0d_4.json b/marketing/conda-meta/vs2015_runtime-14.42.34433-he0abc0d_4.json
new file mode 100644
index 0000000000000000000000000000000000000000..8107c964aa5c094783ba8f9d1e2cfcb573a69de8
--- /dev/null
+++ b/marketing/conda-meta/vs2015_runtime-14.42.34433-he0abc0d_4.json
@@ -0,0 +1,952 @@
+{
+  "build": "he0abc0d_4",
+  "build_number": 4,
+  "channel": "https://repo.anaconda.com/pkgs/main/win-64",
+  "constrains": [],
+  "depends": [],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\vs2015_runtime-14.42.34433-he0abc0d_4",
+  "features": "",
+  "files": [
+    "Library/bin/api-ms-win-core-console-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-console-l1-2-0.dll",
+    "Library/bin/api-ms-win-core-datetime-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-debug-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-errorhandling-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-fibers-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-file-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-file-l1-2-0.dll",
+    "Library/bin/api-ms-win-core-file-l2-1-0.dll",
+    "Library/bin/api-ms-win-core-handle-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-heap-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-interlocked-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-libraryloader-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-localization-l1-2-0.dll",
+    "Library/bin/api-ms-win-core-memory-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-namedpipe-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-processenvironment-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-processthreads-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-processthreads-l1-1-1.dll",
+    "Library/bin/api-ms-win-core-profile-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-rtlsupport-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-string-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-synch-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-synch-l1-2-0.dll",
+    "Library/bin/api-ms-win-core-sysinfo-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-timezone-l1-1-0.dll",
+    "Library/bin/api-ms-win-core-util-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-conio-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-convert-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-environment-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-filesystem-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-heap-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-locale-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-math-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-multibyte-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-private-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-process-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-runtime-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-stdio-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-string-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-time-l1-1-0.dll",
+    "Library/bin/api-ms-win-crt-utility-l1-1-0.dll",
+    "Library/bin/concrt140.dll",
+    "Library/bin/msvcp140.dll",
+    "Library/bin/msvcp140_1.dll",
+    "Library/bin/msvcp140_2.dll",
+    "Library/bin/msvcp140_atomic_wait.dll",
+    "Library/bin/msvcp140_codecvt_ids.dll",
+    "Library/bin/ucrtbase.dll",
+    "Library/bin/vccorlib140.dll",
+    "Library/bin/vcomp140.dll",
+    "Library/bin/vcruntime140.dll",
+    "Library/bin/vcruntime140_1.dll",
+    "Library/bin/vcruntime140_threads.dll",
+    "api-ms-win-core-console-l1-1-0.dll",
+    "api-ms-win-core-console-l1-2-0.dll",
+    "api-ms-win-core-datetime-l1-1-0.dll",
+    "api-ms-win-core-debug-l1-1-0.dll",
+    "api-ms-win-core-errorhandling-l1-1-0.dll",
+    "api-ms-win-core-fibers-l1-1-0.dll",
+    "api-ms-win-core-file-l1-1-0.dll",
+    "api-ms-win-core-file-l1-2-0.dll",
+    "api-ms-win-core-file-l2-1-0.dll",
+    "api-ms-win-core-handle-l1-1-0.dll",
+    "api-ms-win-core-heap-l1-1-0.dll",
+    "api-ms-win-core-interlocked-l1-1-0.dll",
+    "api-ms-win-core-libraryloader-l1-1-0.dll",
+    "api-ms-win-core-localization-l1-2-0.dll",
+    "api-ms-win-core-memory-l1-1-0.dll",
+    "api-ms-win-core-namedpipe-l1-1-0.dll",
+    "api-ms-win-core-processenvironment-l1-1-0.dll",
+    "api-ms-win-core-processthreads-l1-1-0.dll",
+    "api-ms-win-core-processthreads-l1-1-1.dll",
+    "api-ms-win-core-profile-l1-1-0.dll",
+    "api-ms-win-core-rtlsupport-l1-1-0.dll",
+    "api-ms-win-core-string-l1-1-0.dll",
+    "api-ms-win-core-synch-l1-1-0.dll",
+    "api-ms-win-core-synch-l1-2-0.dll",
+    "api-ms-win-core-sysinfo-l1-1-0.dll",
+    "api-ms-win-core-timezone-l1-1-0.dll",
+    "api-ms-win-core-util-l1-1-0.dll",
+    "api-ms-win-crt-conio-l1-1-0.dll",
+    "api-ms-win-crt-convert-l1-1-0.dll",
+    "api-ms-win-crt-environment-l1-1-0.dll",
+    "api-ms-win-crt-filesystem-l1-1-0.dll",
+    "api-ms-win-crt-heap-l1-1-0.dll",
+    "api-ms-win-crt-locale-l1-1-0.dll",
+    "api-ms-win-crt-math-l1-1-0.dll",
+    "api-ms-win-crt-multibyte-l1-1-0.dll",
+    "api-ms-win-crt-private-l1-1-0.dll",
+    "api-ms-win-crt-process-l1-1-0.dll",
+    "api-ms-win-crt-runtime-l1-1-0.dll",
+    "api-ms-win-crt-stdio-l1-1-0.dll",
+    "api-ms-win-crt-string-l1-1-0.dll",
+    "api-ms-win-crt-time-l1-1-0.dll",
+    "api-ms-win-crt-utility-l1-1-0.dll",
+    "concrt140.dll",
+    "msvcp140.dll",
+    "msvcp140_1.dll",
+    "msvcp140_2.dll",
+    "msvcp140_atomic_wait.dll",
+    "msvcp140_codecvt_ids.dll",
+    "ucrtbase.dll",
+    "vccorlib140.dll",
+    "vcomp140.dll",
+    "vcruntime140.dll",
+    "vcruntime140_1.dll",
+    "vcruntime140_threads.dll",
+    ".nonadmin"
+  ],
+  "fn": "vs2015_runtime-14.42.34433-he0abc0d_4.conda",
+  "legacy_bz2_md5": "4c0af6c22468d1a5ad1654d895128006",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\vs2015_runtime-14.42.34433-he0abc0d_4",
+    "type": 1
+  },
+  "md5": "ac6b66049b87b660a89d58c35c620801",
+  "name": "vs2015_runtime",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\vs2015_runtime-14.42.34433-he0abc0d_4.conda",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "Library/bin/api-ms-win-core-console-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "22b0d0412c274a04d11d7fd3f6545eff245e6f032e21b86d920c2844dd1007c6",
+        "sha256_in_prefix": "22b0d0412c274a04d11d7fd3f6545eff245e6f032e21b86d920c2844dd1007c6",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-console-l1-2-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "0c60ddcfddc6e11d77354d5695b822881f37fb537192e61e62f2ebd703fb2119",
+        "sha256_in_prefix": "0c60ddcfddc6e11d77354d5695b822881f37fb537192e61e62f2ebd703fb2119",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-datetime-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "631a106755f13a78032d7c17cd19c5185fe89d93fda2ac108c4f53e27dcdecdb",
+        "sha256_in_prefix": "631a106755f13a78032d7c17cd19c5185fe89d93fda2ac108c4f53e27dcdecdb",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-debug-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "1ce185afeea0a30a12b496d95df395c18bd0e99570c0ac3126758476d4b6aea0",
+        "sha256_in_prefix": "1ce185afeea0a30a12b496d95df395c18bd0e99570c0ac3126758476d4b6aea0",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-errorhandling-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "cdbc9ee30658188fd9af68ad52b5d8e7f59111191b0681ec2ed9095d9c85ebee",
+        "sha256_in_prefix": "cdbc9ee30658188fd9af68ad52b5d8e7f59111191b0681ec2ed9095d9c85ebee",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-fibers-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "938a52984e7e9ffeef350a794907639d453e346d5bdc0aec8c1360d040cc672a",
+        "sha256_in_prefix": "938a52984e7e9ffeef350a794907639d453e346d5bdc0aec8c1360d040cc672a",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-file-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "f36025fd0715ec893c112f06472072c565385b8c5fa675cce5b4a9158bfb87e9",
+        "sha256_in_prefix": "f36025fd0715ec893c112f06472072c565385b8c5fa675cce5b4a9158bfb87e9",
+        "size_in_bytes": 26232
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-file-l1-2-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "3d95961590fe6da5c569bcb0a54651488e70dd7b15c257e1b9faf8a3cc0e63e4",
+        "sha256_in_prefix": "3d95961590fe6da5c569bcb0a54651488e70dd7b15c257e1b9faf8a3cc0e63e4",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-file-l2-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "c6515fb573cd8190ebc401aab4646069066205ee9eeca548ae5ddbec3633336b",
+        "sha256_in_prefix": "c6515fb573cd8190ebc401aab4646069066205ee9eeca548ae5ddbec3633336b",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-handle-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "523b4c1528aab62c5f8622e4e2c4a4ba0df43114098a05f0c58c69c716c42626",
+        "sha256_in_prefix": "523b4c1528aab62c5f8622e4e2c4a4ba0df43114098a05f0c58c69c716c42626",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-heap-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "4fff338c18ab8a1a37d1190e3b9edcca55afa86b0ba0f97d87c4c841e4e29678",
+        "sha256_in_prefix": "4fff338c18ab8a1a37d1190e3b9edcca55afa86b0ba0f97d87c4c841e4e29678",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-interlocked-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "841aa4632552c47b43d453968da2c8d0861b1eb776d530a4e985d0290516d6c8",
+        "sha256_in_prefix": "841aa4632552c47b43d453968da2c8d0861b1eb776d530a4e985d0290516d6c8",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-libraryloader-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "e989c62edade6b3333d798e0481f4c2ec08f7d2a0c47acfcca2a869cd4b68a1f",
+        "sha256_in_prefix": "e989c62edade6b3333d798e0481f4c2ec08f7d2a0c47acfcca2a869cd4b68a1f",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-localization-l1-2-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "945dacfe53f62d83acd0537a6712658558faafb18f68b76b88127db78482fd8f",
+        "sha256_in_prefix": "945dacfe53f62d83acd0537a6712658558faafb18f68b76b88127db78482fd8f",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-memory-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "a505bdf2e4dfd5120de230fd9d159ef75aa00fb3f98e24d259f5c0a456713c74",
+        "sha256_in_prefix": "a505bdf2e4dfd5120de230fd9d159ef75aa00fb3f98e24d259f5c0a456713c74",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-namedpipe-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "b26de5e517b05e10ee34fdf4996f82c465668670329e7f19d21f39a7e39011e7",
+        "sha256_in_prefix": "b26de5e517b05e10ee34fdf4996f82c465668670329e7f19d21f39a7e39011e7",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-processenvironment-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "32d11f07156248c7906027e0f17e93e51de848f136e6d3fd0d4f9d1ffb2c70da",
+        "sha256_in_prefix": "32d11f07156248c7906027e0f17e93e51de848f136e6d3fd0d4f9d1ffb2c70da",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-processthreads-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "562e2619e1e685080faf2122c12ae3c35202ce34ce8330d1ff0a3b566095fd38",
+        "sha256_in_prefix": "562e2619e1e685080faf2122c12ae3c35202ce34ce8330d1ff0a3b566095fd38",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-processthreads-l1-1-1.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "73fabc60a9b24c1eb65ec886a59a190046af5853800572df1d48634417a15729",
+        "sha256_in_prefix": "73fabc60a9b24c1eb65ec886a59a190046af5853800572df1d48634417a15729",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-profile-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "2401cc9407ebb1fa60ddf520d422ec1eefec050dd9871554756c869c9b730558",
+        "sha256_in_prefix": "2401cc9407ebb1fa60ddf520d422ec1eefec050dd9871554756c869c9b730558",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-rtlsupport-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "b5a61cd60ec9088ee27bf61d37c55abc9d6db3f722616d74fc191cf671a4902a",
+        "sha256_in_prefix": "b5a61cd60ec9088ee27bf61d37c55abc9d6db3f722616d74fc191cf671a4902a",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-string-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "7e97fbf5cee26ab01227d564f023337736310868c1cf23920e4dceeeb1c11701",
+        "sha256_in_prefix": "7e97fbf5cee26ab01227d564f023337736310868c1cf23920e4dceeeb1c11701",
+        "size_in_bytes": 22112
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-synch-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "4f47aad2664ed21dd80d30ffd954a34503ffe2493bebb39da058d452212e75af",
+        "sha256_in_prefix": "4f47aad2664ed21dd80d30ffd954a34503ffe2493bebb39da058d452212e75af",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-synch-l1-2-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "a885774d4a5419db2e9f7fbd0ac06f7244e046aa614cd6585ab22fc428f2c7ee",
+        "sha256_in_prefix": "a885774d4a5419db2e9f7fbd0ac06f7244e046aa614cd6585ab22fc428f2c7ee",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-sysinfo-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "ac3b86a3e66c5ae2cb30d8a386b0574e6b59fe0f549120c16b7790c3489bc593",
+        "sha256_in_prefix": "ac3b86a3e66c5ae2cb30d8a386b0574e6b59fe0f549120c16b7790c3489bc593",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-timezone-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "003751ed79881bce98017b66206a2ba411321edd61fd51768779f29dfa99968d",
+        "sha256_in_prefix": "003751ed79881bce98017b66206a2ba411321edd61fd51768779f29dfa99968d",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-core-util-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "eb41c514f2660813fa6ac58a28bcd2adfb64552b945dfcad5123f51a1a71f863",
+        "sha256_in_prefix": "eb41c514f2660813fa6ac58a28bcd2adfb64552b945dfcad5123f51a1a71f863",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-conio-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "e7fc8d3956ce856b1ce0b8d16c10fa4c886a33717a64b818aa6d2492d7492429",
+        "sha256_in_prefix": "e7fc8d3956ce856b1ce0b8d16c10fa4c886a33717a64b818aa6d2492d7492429",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-convert-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "4d80b38c49c9e507190b133e97c7b06ac926c5e1d93095bef8e35c51e7be4e3c",
+        "sha256_in_prefix": "4d80b38c49c9e507190b133e97c7b06ac926c5e1d93095bef8e35c51e7be4e3c",
+        "size_in_bytes": 26216
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-environment-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "65eb6a1276426e0bffc0a7686770cae2fb15a0f819cab4b96003a292c483ec5d",
+        "sha256_in_prefix": "65eb6a1276426e0bffc0a7686770cae2fb15a0f819cab4b96003a292c483ec5d",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-filesystem-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "61424c4c6cf665ef1c6e092a105721813d495ff17d81c809b505acf9ac0c575a",
+        "sha256_in_prefix": "61424c4c6cf665ef1c6e092a105721813d495ff17d81c809b505acf9ac0c575a",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-heap-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "42fed4693a9f2ee8ebb29b34ac92aaef9ff070f609e0cbff74258f65ea53d666",
+        "sha256_in_prefix": "42fed4693a9f2ee8ebb29b34ac92aaef9ff070f609e0cbff74258f65ea53d666",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-locale-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "f2d099d580c733d3132ac3cd0179c7bfa0f1ed8f7bd063e411cd57e920510488",
+        "sha256_in_prefix": "f2d099d580c733d3132ac3cd0179c7bfa0f1ed8f7bd063e411cd57e920510488",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-math-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "8483828a6781dc3cc4a121e2a90f54abb6f6c42680a0634e02db8b736d16f877",
+        "sha256_in_prefix": "8483828a6781dc3cc4a121e2a90f54abb6f6c42680a0634e02db8b736d16f877",
+        "size_in_bytes": 30328
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-multibyte-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "63c233965965c6eab235c0e1e7530788fee44d5cab910a2cd22d325334a3dce2",
+        "sha256_in_prefix": "63c233965965c6eab235c0e1e7530788fee44d5cab910a2cd22d325334a3dce2",
+        "size_in_bytes": 30328
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-private-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "65e8380924c6b54147185cfd84deb0795c617b8c316d3767daa616f9fd88d6c0",
+        "sha256_in_prefix": "65e8380924c6b54147185cfd84deb0795c617b8c316d3767daa616f9fd88d6c0",
+        "size_in_bytes": 75368
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-process-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "f426c73f187c4c3c6759514c11f752a1f8411a1f4392bbee984652e62d2e7296",
+        "sha256_in_prefix": "f426c73f187c4c3c6759514c11f752a1f8411a1f4392bbee984652e62d2e7296",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-runtime-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "21c3d46f74f4249c81d723373da639ac2fb2733a626ec11310df49874663d2bc",
+        "sha256_in_prefix": "21c3d46f74f4249c81d723373da639ac2fb2733a626ec11310df49874663d2bc",
+        "size_in_bytes": 26216
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-stdio-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "e4a6bd5d65d39da4424ab7828959cfeb7c362e29008bc63ecf16fb3b20001807",
+        "sha256_in_prefix": "e4a6bd5d65d39da4424ab7828959cfeb7c362e29008bc63ecf16fb3b20001807",
+        "size_in_bytes": 26216
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-string-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "a1cf3656daa57afb840714f891e7f072ca56bf5838f525d4394c362ef5c8ed8f",
+        "sha256_in_prefix": "a1cf3656daa57afb840714f891e7f072ca56bf5838f525d4394c362ef5c8ed8f",
+        "size_in_bytes": 26216
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-time-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "fc27f6061faf91d696a2b3685a3bfac4de49fbf78d578b9970e1ed21f683b209",
+        "sha256_in_prefix": "fc27f6061faf91d696a2b3685a3bfac4de49fbf78d578b9970e1ed21f683b209",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "Library/bin/api-ms-win-crt-utility-l1-1-0.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "788611c05ef16759ac57df231b25b413be33fccabbeb446caaf4b5cbedd8e1dc",
+        "sha256_in_prefix": "788611c05ef16759ac57df231b25b413be33fccabbeb446caaf4b5cbedd8e1dc",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "Library/bin/concrt140.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "e2e4609c569c69f7b1686f6d0e81ce62187ac5df05e0247954500053b3c3de3f",
+        "sha256_in_prefix": "e2e4609c569c69f7b1686f6d0e81ce62187ac5df05e0247954500053b3c3de3f",
+        "size_in_bytes": 322640
+      },
+      {
+        "_path": "Library/bin/msvcp140.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "9057d39b36b6c7d054865ee2bf9cde7a490fe3b01ec4e82514687e24f576269f",
+        "sha256_in_prefix": "9057d39b36b6c7d054865ee2bf9cde7a490fe3b01ec4e82514687e24f576269f",
+        "size_in_bytes": 575592
+      },
+      {
+        "_path": "Library/bin/msvcp140_1.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "a65249861238e1c18b84ae5d112617c438d83a76b67eddc170ad82dbc2338665",
+        "sha256_in_prefix": "a65249861238e1c18b84ae5d112617c438d83a76b67eddc170ad82dbc2338665",
+        "size_in_bytes": 35944
+      },
+      {
+        "_path": "Library/bin/msvcp140_2.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "89e2e9a163165e20c540f9adea081e927ddfe4a556547b0f45f11586d4cce165",
+        "sha256_in_prefix": "89e2e9a163165e20c540f9adea081e927ddfe4a556547b0f45f11586d4cce165",
+        "size_in_bytes": 267880
+      },
+      {
+        "_path": "Library/bin/msvcp140_atomic_wait.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "fbf41e4b53f51bbf73fee37b6120103fea6b7d5ae29916f8ef50c50cfdedeead",
+        "sha256_in_prefix": "fbf41e4b53f51bbf73fee37b6120103fea6b7d5ae29916f8ef50c50cfdedeead",
+        "size_in_bytes": 50256
+      },
+      {
+        "_path": "Library/bin/msvcp140_codecvt_ids.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "0e1d3d76e899a89fb3893fb13abae232ff62ad4f573214dd2f02b8398166bcc6",
+        "sha256_in_prefix": "0e1d3d76e899a89fb3893fb13abae232ff62ad4f573214dd2f02b8398166bcc6",
+        "size_in_bytes": 31824
+      },
+      {
+        "_path": "Library/bin/ucrtbase.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "91d027417ff2301b7135e864a5df6693488f8412ff87040f4897e0e03bc2577b",
+        "sha256_in_prefix": "91d027417ff2301b7135e864a5df6693488f8412ff87040f4897e0e03bc2577b",
+        "size_in_bytes": 1123944
+      },
+      {
+        "_path": "Library/bin/vccorlib140.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "8903b5d88968791d2a93648a54a1ac3d1c708c579a72311ffe194f6d66903043",
+        "sha256_in_prefix": "8903b5d88968791d2a93648a54a1ac3d1c708c579a72311ffe194f6d66903043",
+        "size_in_bytes": 351824
+      },
+      {
+        "_path": "Library/bin/vcomp140.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "036b9b3f7ece8dfd48aeccd77113721c5305043aaa9c64d1e72812252727aa7c",
+        "sha256_in_prefix": "036b9b3f7ece8dfd48aeccd77113721c5305043aaa9c64d1e72812252727aa7c",
+        "size_in_bytes": 192104
+      },
+      {
+        "_path": "Library/bin/vcruntime140.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "da72e6677bd1bcd01c453c1998aaa19aeaf6659f4774cf6848409da8232a95b2",
+        "sha256_in_prefix": "da72e6677bd1bcd01c453c1998aaa19aeaf6659f4774cf6848409da8232a95b2",
+        "size_in_bytes": 120432
+      },
+      {
+        "_path": "Library/bin/vcruntime140_1.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "26e470b29bed3d873e0c328186e53f95e9edbfe0b0fd0cda44743a0b1a04a828",
+        "sha256_in_prefix": "26e470b29bed3d873e0c328186e53f95e9edbfe0b0fd0cda44743a0b1a04a828",
+        "size_in_bytes": 49744
+      },
+      {
+        "_path": "Library/bin/vcruntime140_threads.dll",
+        "no_link": true,
+        "path_type": "hardlink",
+        "sha256": "326110c8c5cac836cfed1643304cb6bdc4a8737a7a535d6b1eff4d63878aef9d",
+        "sha256_in_prefix": "326110c8c5cac836cfed1643304cb6bdc4a8737a7a535d6b1eff4d63878aef9d",
+        "size_in_bytes": 38504
+      },
+      {
+        "_path": "api-ms-win-core-console-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "22b0d0412c274a04d11d7fd3f6545eff245e6f032e21b86d920c2844dd1007c6",
+        "sha256_in_prefix": "22b0d0412c274a04d11d7fd3f6545eff245e6f032e21b86d920c2844dd1007c6",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-console-l1-2-0.dll",
+        "path_type": "hardlink",
+        "sha256": "0c60ddcfddc6e11d77354d5695b822881f37fb537192e61e62f2ebd703fb2119",
+        "sha256_in_prefix": "0c60ddcfddc6e11d77354d5695b822881f37fb537192e61e62f2ebd703fb2119",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-datetime-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "631a106755f13a78032d7c17cd19c5185fe89d93fda2ac108c4f53e27dcdecdb",
+        "sha256_in_prefix": "631a106755f13a78032d7c17cd19c5185fe89d93fda2ac108c4f53e27dcdecdb",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-core-debug-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "1ce185afeea0a30a12b496d95df395c18bd0e99570c0ac3126758476d4b6aea0",
+        "sha256_in_prefix": "1ce185afeea0a30a12b496d95df395c18bd0e99570c0ac3126758476d4b6aea0",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-errorhandling-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "cdbc9ee30658188fd9af68ad52b5d8e7f59111191b0681ec2ed9095d9c85ebee",
+        "sha256_in_prefix": "cdbc9ee30658188fd9af68ad52b5d8e7f59111191b0681ec2ed9095d9c85ebee",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-fibers-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "938a52984e7e9ffeef350a794907639d453e346d5bdc0aec8c1360d040cc672a",
+        "sha256_in_prefix": "938a52984e7e9ffeef350a794907639d453e346d5bdc0aec8c1360d040cc672a",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-file-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "f36025fd0715ec893c112f06472072c565385b8c5fa675cce5b4a9158bfb87e9",
+        "sha256_in_prefix": "f36025fd0715ec893c112f06472072c565385b8c5fa675cce5b4a9158bfb87e9",
+        "size_in_bytes": 26232
+      },
+      {
+        "_path": "api-ms-win-core-file-l1-2-0.dll",
+        "path_type": "hardlink",
+        "sha256": "3d95961590fe6da5c569bcb0a54651488e70dd7b15c257e1b9faf8a3cc0e63e4",
+        "sha256_in_prefix": "3d95961590fe6da5c569bcb0a54651488e70dd7b15c257e1b9faf8a3cc0e63e4",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-core-file-l2-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "c6515fb573cd8190ebc401aab4646069066205ee9eeca548ae5ddbec3633336b",
+        "sha256_in_prefix": "c6515fb573cd8190ebc401aab4646069066205ee9eeca548ae5ddbec3633336b",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-core-handle-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "523b4c1528aab62c5f8622e4e2c4a4ba0df43114098a05f0c58c69c716c42626",
+        "sha256_in_prefix": "523b4c1528aab62c5f8622e4e2c4a4ba0df43114098a05f0c58c69c716c42626",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-heap-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "4fff338c18ab8a1a37d1190e3b9edcca55afa86b0ba0f97d87c4c841e4e29678",
+        "sha256_in_prefix": "4fff338c18ab8a1a37d1190e3b9edcca55afa86b0ba0f97d87c4c841e4e29678",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-interlocked-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "841aa4632552c47b43d453968da2c8d0861b1eb776d530a4e985d0290516d6c8",
+        "sha256_in_prefix": "841aa4632552c47b43d453968da2c8d0861b1eb776d530a4e985d0290516d6c8",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-core-libraryloader-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "e989c62edade6b3333d798e0481f4c2ec08f7d2a0c47acfcca2a869cd4b68a1f",
+        "sha256_in_prefix": "e989c62edade6b3333d798e0481f4c2ec08f7d2a0c47acfcca2a869cd4b68a1f",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-localization-l1-2-0.dll",
+        "path_type": "hardlink",
+        "sha256": "945dacfe53f62d83acd0537a6712658558faafb18f68b76b88127db78482fd8f",
+        "sha256_in_prefix": "945dacfe53f62d83acd0537a6712658558faafb18f68b76b88127db78482fd8f",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-memory-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "a505bdf2e4dfd5120de230fd9d159ef75aa00fb3f98e24d259f5c0a456713c74",
+        "sha256_in_prefix": "a505bdf2e4dfd5120de230fd9d159ef75aa00fb3f98e24d259f5c0a456713c74",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-namedpipe-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "b26de5e517b05e10ee34fdf4996f82c465668670329e7f19d21f39a7e39011e7",
+        "sha256_in_prefix": "b26de5e517b05e10ee34fdf4996f82c465668670329e7f19d21f39a7e39011e7",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-processenvironment-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "32d11f07156248c7906027e0f17e93e51de848f136e6d3fd0d4f9d1ffb2c70da",
+        "sha256_in_prefix": "32d11f07156248c7906027e0f17e93e51de848f136e6d3fd0d4f9d1ffb2c70da",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-processthreads-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "562e2619e1e685080faf2122c12ae3c35202ce34ce8330d1ff0a3b566095fd38",
+        "sha256_in_prefix": "562e2619e1e685080faf2122c12ae3c35202ce34ce8330d1ff0a3b566095fd38",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-core-processthreads-l1-1-1.dll",
+        "path_type": "hardlink",
+        "sha256": "73fabc60a9b24c1eb65ec886a59a190046af5853800572df1d48634417a15729",
+        "sha256_in_prefix": "73fabc60a9b24c1eb65ec886a59a190046af5853800572df1d48634417a15729",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-core-profile-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "2401cc9407ebb1fa60ddf520d422ec1eefec050dd9871554756c869c9b730558",
+        "sha256_in_prefix": "2401cc9407ebb1fa60ddf520d422ec1eefec050dd9871554756c869c9b730558",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-core-rtlsupport-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "b5a61cd60ec9088ee27bf61d37c55abc9d6db3f722616d74fc191cf671a4902a",
+        "sha256_in_prefix": "b5a61cd60ec9088ee27bf61d37c55abc9d6db3f722616d74fc191cf671a4902a",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-string-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "7e97fbf5cee26ab01227d564f023337736310868c1cf23920e4dceeeb1c11701",
+        "sha256_in_prefix": "7e97fbf5cee26ab01227d564f023337736310868c1cf23920e4dceeeb1c11701",
+        "size_in_bytes": 22112
+      },
+      {
+        "_path": "api-ms-win-core-synch-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "4f47aad2664ed21dd80d30ffd954a34503ffe2493bebb39da058d452212e75af",
+        "sha256_in_prefix": "4f47aad2664ed21dd80d30ffd954a34503ffe2493bebb39da058d452212e75af",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-synch-l1-2-0.dll",
+        "path_type": "hardlink",
+        "sha256": "a885774d4a5419db2e9f7fbd0ac06f7244e046aa614cd6585ab22fc428f2c7ee",
+        "sha256_in_prefix": "a885774d4a5419db2e9f7fbd0ac06f7244e046aa614cd6585ab22fc428f2c7ee",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-core-sysinfo-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "ac3b86a3e66c5ae2cb30d8a386b0574e6b59fe0f549120c16b7790c3489bc593",
+        "sha256_in_prefix": "ac3b86a3e66c5ae2cb30d8a386b0574e6b59fe0f549120c16b7790c3489bc593",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-core-timezone-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "003751ed79881bce98017b66206a2ba411321edd61fd51768779f29dfa99968d",
+        "sha256_in_prefix": "003751ed79881bce98017b66206a2ba411321edd61fd51768779f29dfa99968d",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-core-util-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "eb41c514f2660813fa6ac58a28bcd2adfb64552b945dfcad5123f51a1a71f863",
+        "sha256_in_prefix": "eb41c514f2660813fa6ac58a28bcd2adfb64552b945dfcad5123f51a1a71f863",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-crt-conio-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "e7fc8d3956ce856b1ce0b8d16c10fa4c886a33717a64b818aa6d2492d7492429",
+        "sha256_in_prefix": "e7fc8d3956ce856b1ce0b8d16c10fa4c886a33717a64b818aa6d2492d7492429",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-crt-convert-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "4d80b38c49c9e507190b133e97c7b06ac926c5e1d93095bef8e35c51e7be4e3c",
+        "sha256_in_prefix": "4d80b38c49c9e507190b133e97c7b06ac926c5e1d93095bef8e35c51e7be4e3c",
+        "size_in_bytes": 26216
+      },
+      {
+        "_path": "api-ms-win-crt-environment-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "65eb6a1276426e0bffc0a7686770cae2fb15a0f819cab4b96003a292c483ec5d",
+        "sha256_in_prefix": "65eb6a1276426e0bffc0a7686770cae2fb15a0f819cab4b96003a292c483ec5d",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-crt-filesystem-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "61424c4c6cf665ef1c6e092a105721813d495ff17d81c809b505acf9ac0c575a",
+        "sha256_in_prefix": "61424c4c6cf665ef1c6e092a105721813d495ff17d81c809b505acf9ac0c575a",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-crt-heap-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "42fed4693a9f2ee8ebb29b34ac92aaef9ff070f609e0cbff74258f65ea53d666",
+        "sha256_in_prefix": "42fed4693a9f2ee8ebb29b34ac92aaef9ff070f609e0cbff74258f65ea53d666",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-crt-locale-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "f2d099d580c733d3132ac3cd0179c7bfa0f1ed8f7bd063e411cd57e920510488",
+        "sha256_in_prefix": "f2d099d580c733d3132ac3cd0179c7bfa0f1ed8f7bd063e411cd57e920510488",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-crt-math-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "8483828a6781dc3cc4a121e2a90f54abb6f6c42680a0634e02db8b736d16f877",
+        "sha256_in_prefix": "8483828a6781dc3cc4a121e2a90f54abb6f6c42680a0634e02db8b736d16f877",
+        "size_in_bytes": 30328
+      },
+      {
+        "_path": "api-ms-win-crt-multibyte-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "63c233965965c6eab235c0e1e7530788fee44d5cab910a2cd22d325334a3dce2",
+        "sha256_in_prefix": "63c233965965c6eab235c0e1e7530788fee44d5cab910a2cd22d325334a3dce2",
+        "size_in_bytes": 30328
+      },
+      {
+        "_path": "api-ms-win-crt-private-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "65e8380924c6b54147185cfd84deb0795c617b8c316d3767daa616f9fd88d6c0",
+        "sha256_in_prefix": "65e8380924c6b54147185cfd84deb0795c617b8c316d3767daa616f9fd88d6c0",
+        "size_in_bytes": 75368
+      },
+      {
+        "_path": "api-ms-win-crt-process-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "f426c73f187c4c3c6759514c11f752a1f8411a1f4392bbee984652e62d2e7296",
+        "sha256_in_prefix": "f426c73f187c4c3c6759514c11f752a1f8411a1f4392bbee984652e62d2e7296",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "api-ms-win-crt-runtime-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "21c3d46f74f4249c81d723373da639ac2fb2733a626ec11310df49874663d2bc",
+        "sha256_in_prefix": "21c3d46f74f4249c81d723373da639ac2fb2733a626ec11310df49874663d2bc",
+        "size_in_bytes": 26216
+      },
+      {
+        "_path": "api-ms-win-crt-stdio-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "e4a6bd5d65d39da4424ab7828959cfeb7c362e29008bc63ecf16fb3b20001807",
+        "sha256_in_prefix": "e4a6bd5d65d39da4424ab7828959cfeb7c362e29008bc63ecf16fb3b20001807",
+        "size_in_bytes": 26216
+      },
+      {
+        "_path": "api-ms-win-crt-string-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "a1cf3656daa57afb840714f891e7f072ca56bf5838f525d4394c362ef5c8ed8f",
+        "sha256_in_prefix": "a1cf3656daa57afb840714f891e7f072ca56bf5838f525d4394c362ef5c8ed8f",
+        "size_in_bytes": 26216
+      },
+      {
+        "_path": "api-ms-win-crt-time-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "fc27f6061faf91d696a2b3685a3bfac4de49fbf78d578b9970e1ed21f683b209",
+        "sha256_in_prefix": "fc27f6061faf91d696a2b3685a3bfac4de49fbf78d578b9970e1ed21f683b209",
+        "size_in_bytes": 22120
+      },
+      {
+        "_path": "api-ms-win-crt-utility-l1-1-0.dll",
+        "path_type": "hardlink",
+        "sha256": "788611c05ef16759ac57df231b25b413be33fccabbeb446caaf4b5cbedd8e1dc",
+        "sha256_in_prefix": "788611c05ef16759ac57df231b25b413be33fccabbeb446caaf4b5cbedd8e1dc",
+        "size_in_bytes": 22136
+      },
+      {
+        "_path": "concrt140.dll",
+        "path_type": "hardlink",
+        "sha256": "e2e4609c569c69f7b1686f6d0e81ce62187ac5df05e0247954500053b3c3de3f",
+        "sha256_in_prefix": "e2e4609c569c69f7b1686f6d0e81ce62187ac5df05e0247954500053b3c3de3f",
+        "size_in_bytes": 322640
+      },
+      {
+        "_path": "msvcp140.dll",
+        "path_type": "hardlink",
+        "sha256": "9057d39b36b6c7d054865ee2bf9cde7a490fe3b01ec4e82514687e24f576269f",
+        "sha256_in_prefix": "9057d39b36b6c7d054865ee2bf9cde7a490fe3b01ec4e82514687e24f576269f",
+        "size_in_bytes": 575592
+      },
+      {
+        "_path": "msvcp140_1.dll",
+        "path_type": "hardlink",
+        "sha256": "a65249861238e1c18b84ae5d112617c438d83a76b67eddc170ad82dbc2338665",
+        "sha256_in_prefix": "a65249861238e1c18b84ae5d112617c438d83a76b67eddc170ad82dbc2338665",
+        "size_in_bytes": 35944
+      },
+      {
+        "_path": "msvcp140_2.dll",
+        "path_type": "hardlink",
+        "sha256": "89e2e9a163165e20c540f9adea081e927ddfe4a556547b0f45f11586d4cce165",
+        "sha256_in_prefix": "89e2e9a163165e20c540f9adea081e927ddfe4a556547b0f45f11586d4cce165",
+        "size_in_bytes": 267880
+      },
+      {
+        "_path": "msvcp140_atomic_wait.dll",
+        "path_type": "hardlink",
+        "sha256": "fbf41e4b53f51bbf73fee37b6120103fea6b7d5ae29916f8ef50c50cfdedeead",
+        "sha256_in_prefix": "fbf41e4b53f51bbf73fee37b6120103fea6b7d5ae29916f8ef50c50cfdedeead",
+        "size_in_bytes": 50256
+      },
+      {
+        "_path": "msvcp140_codecvt_ids.dll",
+        "path_type": "hardlink",
+        "sha256": "0e1d3d76e899a89fb3893fb13abae232ff62ad4f573214dd2f02b8398166bcc6",
+        "sha256_in_prefix": "0e1d3d76e899a89fb3893fb13abae232ff62ad4f573214dd2f02b8398166bcc6",
+        "size_in_bytes": 31824
+      },
+      {
+        "_path": "ucrtbase.dll",
+        "path_type": "hardlink",
+        "sha256": "91d027417ff2301b7135e864a5df6693488f8412ff87040f4897e0e03bc2577b",
+        "sha256_in_prefix": "91d027417ff2301b7135e864a5df6693488f8412ff87040f4897e0e03bc2577b",
+        "size_in_bytes": 1123944
+      },
+      {
+        "_path": "vccorlib140.dll",
+        "path_type": "hardlink",
+        "sha256": "8903b5d88968791d2a93648a54a1ac3d1c708c579a72311ffe194f6d66903043",
+        "sha256_in_prefix": "8903b5d88968791d2a93648a54a1ac3d1c708c579a72311ffe194f6d66903043",
+        "size_in_bytes": 351824
+      },
+      {
+        "_path": "vcomp140.dll",
+        "path_type": "hardlink",
+        "sha256": "036b9b3f7ece8dfd48aeccd77113721c5305043aaa9c64d1e72812252727aa7c",
+        "sha256_in_prefix": "036b9b3f7ece8dfd48aeccd77113721c5305043aaa9c64d1e72812252727aa7c",
+        "size_in_bytes": 192104
+      },
+      {
+        "_path": "vcruntime140.dll",
+        "path_type": "hardlink",
+        "sha256": "da72e6677bd1bcd01c453c1998aaa19aeaf6659f4774cf6848409da8232a95b2",
+        "sha256_in_prefix": "da72e6677bd1bcd01c453c1998aaa19aeaf6659f4774cf6848409da8232a95b2",
+        "size_in_bytes": 120432
+      },
+      {
+        "_path": "vcruntime140_1.dll",
+        "path_type": "hardlink",
+        "sha256": "26e470b29bed3d873e0c328186e53f95e9edbfe0b0fd0cda44743a0b1a04a828",
+        "sha256_in_prefix": "26e470b29bed3d873e0c328186e53f95e9edbfe0b0fd0cda44743a0b1a04a828",
+        "size_in_bytes": 49744
+      },
+      {
+        "_path": "vcruntime140_threads.dll",
+        "path_type": "hardlink",
+        "sha256": "326110c8c5cac836cfed1643304cb6bdc4a8737a7a535d6b1eff4d63878aef9d",
+        "sha256_in_prefix": "326110c8c5cac836cfed1643304cb6bdc4a8737a7a535d6b1eff4d63878aef9d",
+        "size_in_bytes": 38504
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "f99e0077b4056bcdfe86f5039ab365c0a337d24c09bf9e03d573628567840017",
+  "size": 1223557,
+  "subdir": "win-64",
+  "timestamp": 1739202634559,
+  "track_features": "",
+  "url": "https://repo.anaconda.com/pkgs/main/win-64/vs2015_runtime-14.42.34433-he0abc0d_4.conda",
+  "version": "14.42.34433"
+}
\ No newline at end of file
diff --git a/marketing/conda-meta/wheel-0.45.1-py39haa95532_0.json b/marketing/conda-meta/wheel-0.45.1-py39haa95532_0.json
new file mode 100644
index 0000000000000000000000000000000000000000..6b819cded834c36a9ab2e84f16fb3ebaad872bdc
--- /dev/null
+++ b/marketing/conda-meta/wheel-0.45.1-py39haa95532_0.json
@@ -0,0 +1,574 @@
+{
+  "build": "py39haa95532_0",
+  "build_number": 0,
+  "channel": "https://repo.anaconda.com/pkgs/main/win-64",
+  "constrains": [],
+  "depends": [
+    "python >=3.9,<3.10.0a0"
+  ],
+  "extracted_package_dir": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\wheel-0.45.1-py39haa95532_0",
+  "features": "",
+  "files": [
+    "Lib/site-packages/wheel-0.45.1.dist-info/LICENSE.txt",
+    "Lib/site-packages/wheel-0.45.1.dist-info/METADATA",
+    "Lib/site-packages/wheel-0.45.1.dist-info/RECORD",
+    "Lib/site-packages/wheel-0.45.1.dist-info/WHEEL",
+    "Lib/site-packages/wheel-0.45.1.dist-info/entry_points.txt",
+    "Lib/site-packages/wheel/__init__.py",
+    "Lib/site-packages/wheel/__main__.py",
+    "Lib/site-packages/wheel/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/wheel/__pycache__/__main__.cpython-39.pyc",
+    "Lib/site-packages/wheel/__pycache__/_bdist_wheel.cpython-39.pyc",
+    "Lib/site-packages/wheel/__pycache__/_setuptools_logging.cpython-39.pyc",
+    "Lib/site-packages/wheel/__pycache__/bdist_wheel.cpython-39.pyc",
+    "Lib/site-packages/wheel/__pycache__/macosx_libfile.cpython-39.pyc",
+    "Lib/site-packages/wheel/__pycache__/metadata.cpython-39.pyc",
+    "Lib/site-packages/wheel/__pycache__/util.cpython-39.pyc",
+    "Lib/site-packages/wheel/__pycache__/wheelfile.cpython-39.pyc",
+    "Lib/site-packages/wheel/_bdist_wheel.py",
+    "Lib/site-packages/wheel/_setuptools_logging.py",
+    "Lib/site-packages/wheel/bdist_wheel.py",
+    "Lib/site-packages/wheel/cli/__init__.py",
+    "Lib/site-packages/wheel/cli/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/wheel/cli/__pycache__/convert.cpython-39.pyc",
+    "Lib/site-packages/wheel/cli/__pycache__/pack.cpython-39.pyc",
+    "Lib/site-packages/wheel/cli/__pycache__/tags.cpython-39.pyc",
+    "Lib/site-packages/wheel/cli/__pycache__/unpack.cpython-39.pyc",
+    "Lib/site-packages/wheel/cli/convert.py",
+    "Lib/site-packages/wheel/cli/pack.py",
+    "Lib/site-packages/wheel/cli/tags.py",
+    "Lib/site-packages/wheel/cli/unpack.py",
+    "Lib/site-packages/wheel/macosx_libfile.py",
+    "Lib/site-packages/wheel/metadata.py",
+    "Lib/site-packages/wheel/util.py",
+    "Lib/site-packages/wheel/vendored/__init__.py",
+    "Lib/site-packages/wheel/vendored/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/LICENSE",
+    "Lib/site-packages/wheel/vendored/packaging/LICENSE.APACHE",
+    "Lib/site-packages/wheel/vendored/packaging/LICENSE.BSD",
+    "Lib/site-packages/wheel/vendored/packaging/__init__.py",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/__init__.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/_elffile.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/_manylinux.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/_musllinux.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/_parser.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/_structures.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/_tokenizer.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/markers.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/requirements.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/specifiers.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/tags.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/utils.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/__pycache__/version.cpython-39.pyc",
+    "Lib/site-packages/wheel/vendored/packaging/_elffile.py",
+    "Lib/site-packages/wheel/vendored/packaging/_manylinux.py",
+    "Lib/site-packages/wheel/vendored/packaging/_musllinux.py",
+    "Lib/site-packages/wheel/vendored/packaging/_parser.py",
+    "Lib/site-packages/wheel/vendored/packaging/_structures.py",
+    "Lib/site-packages/wheel/vendored/packaging/_tokenizer.py",
+    "Lib/site-packages/wheel/vendored/packaging/markers.py",
+    "Lib/site-packages/wheel/vendored/packaging/requirements.py",
+    "Lib/site-packages/wheel/vendored/packaging/specifiers.py",
+    "Lib/site-packages/wheel/vendored/packaging/tags.py",
+    "Lib/site-packages/wheel/vendored/packaging/utils.py",
+    "Lib/site-packages/wheel/vendored/packaging/version.py",
+    "Lib/site-packages/wheel/vendored/vendor.txt",
+    "Lib/site-packages/wheel/wheelfile.py",
+    "Scripts/wheel-script.py",
+    "Scripts/wheel.exe",
+    ".nonadmin"
+  ],
+  "fn": "wheel-0.45.1-py39haa95532_0.conda",
+  "legacy_bz2_md5": "ab65efb9ea8a01a539f12b1f56f4169e",
+  "license": "MIT",
+  "license_family": "MIT",
+  "link": {
+    "source": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\wheel-0.45.1-py39haa95532_0",
+    "type": 1
+  },
+  "md5": "77878e5a74e2372b525e29dc623b55eb",
+  "name": "wheel",
+  "package_tarball_full_path": "C:\\Users\\mustafa.tark\\Anaconda3\\pkgs\\wheel-0.45.1-py39haa95532_0.conda",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "Lib/site-packages/wheel-0.45.1.dist-info/LICENSE.txt",
+        "path_type": "hardlink",
+        "sha256": "30c23618679108f3e8ea1d2a658c7ca417bdfc891c98ef1a89fa4ff0c9828654",
+        "sha256_in_prefix": "30c23618679108f3e8ea1d2a658c7ca417bdfc891c98ef1a89fa4ff0c9828654",
+        "size_in_bytes": 1107
+      },
+      {
+        "_path": "Lib/site-packages/wheel-0.45.1.dist-info/METADATA",
+        "path_type": "hardlink",
+        "sha256": "b04e96136b82c11487b79640c093a7344af76607ec497a24f4b87b2518590a60",
+        "sha256_in_prefix": "b04e96136b82c11487b79640c093a7344af76607ec497a24f4b87b2518590a60",
+        "size_in_bytes": 2313
+      },
+      {
+        "_path": "Lib/site-packages/wheel-0.45.1.dist-info/RECORD",
+        "path_type": "hardlink",
+        "sha256": "9a506837367672d2a8417de463a858dd839fe7bc711125d0270ce5fcae3f3222",
+        "sha256_in_prefix": "9a506837367672d2a8417de463a858dd839fe7bc711125d0270ce5fcae3f3222",
+        "size_in_bytes": 3188
+      },
+      {
+        "_path": "Lib/site-packages/wheel-0.45.1.dist-info/WHEEL",
+        "path_type": "hardlink",
+        "sha256": "1196c6921ec87b83e865f450f08d19b8ff5592537f4ef719e83484e546abe33e",
+        "sha256_in_prefix": "1196c6921ec87b83e865f450f08d19b8ff5592537f4ef719e83484e546abe33e",
+        "size_in_bytes": 81
+      },
+      {
+        "_path": "Lib/site-packages/wheel-0.45.1.dist-info/entry_points.txt",
+        "path_type": "hardlink",
+        "sha256": "ad363505b90f1e1906326e10dc5d29233241cd6da4331a06d68ae27dfbc6740d",
+        "sha256_in_prefix": "ad363505b90f1e1906326e10dc5d29233241cd6da4331a06d68ae27dfbc6740d",
+        "size_in_bytes": 104
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "9abc4c9ef757002babfcb59e81b51f879839cac599addeb75099fcf74c2f18d9",
+        "sha256_in_prefix": "9abc4c9ef757002babfcb59e81b51f879839cac599addeb75099fcf74c2f18d9",
+        "size_in_bytes": 59
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__main__.py",
+        "path_type": "hardlink",
+        "sha256": "3643149ee4c219c3a4818d0804b8010950bf04619c58e471d8af236064b5d941",
+        "sha256_in_prefix": "3643149ee4c219c3a4818d0804b8010950bf04619c58e471d8af236064b5d941",
+        "size_in_bytes": 455
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "be4368823be13403507fb36d839859d3ff13cacb1f5e7237ea3753e8460fc292",
+        "sha256_in_prefix": "be4368823be13403507fb36d839859d3ff13cacb1f5e7237ea3753e8460fc292",
+        "size_in_bytes": 199
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__pycache__/__main__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "d1033b10d70974b743b9ab71676881b259e17eb625a8046270c3c5dd22ca0e73",
+        "sha256_in_prefix": "d1033b10d70974b743b9ab71676881b259e17eb625a8046270c3c5dd22ca0e73",
+        "size_in_bytes": 591
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__pycache__/_bdist_wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ec81dc9b57d17ec15a8b7c8150c069eb7494f2aa1f1c3d07a3d1cffe5013a053",
+        "sha256_in_prefix": "ec81dc9b57d17ec15a8b7c8150c069eb7494f2aa1f1c3d07a3d1cffe5013a053",
+        "size_in_bytes": 14983
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__pycache__/_setuptools_logging.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "fbc05480523fead841b6e052c8260d51ba40ca61792e263746f64ceaf45104df",
+        "sha256_in_prefix": "fbc05480523fead841b6e052c8260d51ba40ca61792e263746f64ceaf45104df",
+        "size_in_bytes": 970
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__pycache__/bdist_wheel.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4ecee2c08fa038487c24e86b8d41c41501469d639f59480cb07e631242e32582",
+        "sha256_in_prefix": "4ecee2c08fa038487c24e86b8d41c41501469d639f59480cb07e631242e32582",
+        "size_in_bytes": 655
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__pycache__/macosx_libfile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4c18f1c09eb240c82d991d63431834f7761c52346f1ea9f1810f33ce0e6333dc",
+        "sha256_in_prefix": "4c18f1c09eb240c82d991d63431834f7761c52346f1ea9f1810f33ce0e6333dc",
+        "size_in_bytes": 10450
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__pycache__/metadata.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4aea426c2d3249a53a3a84a6de9327b339ae48aeea8bb44d433411a1d4b2f845",
+        "sha256_in_prefix": "4aea426c2d3249a53a3a84a6de9327b339ae48aeea8bb44d433411a1d4b2f845",
+        "size_in_bytes": 6033
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__pycache__/util.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "4774e24d075559aa2b79317d9f184ad4bed63af46a139cb4ca453463cd338178",
+        "sha256_in_prefix": "4774e24d075559aa2b79317d9f184ad4bed63af46a139cb4ca453463cd338178",
+        "size_in_bytes": 672
+      },
+      {
+        "_path": "Lib/site-packages/wheel/__pycache__/wheelfile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "9392f92aca95ed4872e55864f765a0594dc705ab63b04490da687c1135008393",
+        "sha256_in_prefix": "9392f92aca95ed4872e55864f765a0594dc705ab63b04490da687c1135008393",
+        "size_in_bytes": 6319
+      },
+      {
+        "_path": "Lib/site-packages/wheel/_bdist_wheel.py",
+        "path_type": "hardlink",
+        "sha256": "520842423487fe955f71987aa118f34b0fd342171fdda9d2c753a488b48bf363",
+        "sha256_in_prefix": "520842423487fe955f71987aa118f34b0fd342171fdda9d2c753a488b48bf363",
+        "size_in_bytes": 21694
+      },
+      {
+        "_path": "Lib/site-packages/wheel/_setuptools_logging.py",
+        "path_type": "hardlink",
+        "sha256": "fb9282fa59ded2294e5162037ce92a6a951618c15986e2980c86af219881e643",
+        "sha256_in_prefix": "fb9282fa59ded2294e5162037ce92a6a951618c15986e2980c86af219881e643",
+        "size_in_bytes": 781
+      },
+      {
+        "_path": "Lib/site-packages/wheel/bdist_wheel.py",
+        "path_type": "hardlink",
+        "sha256": "b697fd5ae7e248ed51b84320e683e121f486f0333388267fe26b82285ebd0aaa",
+        "sha256_in_prefix": "b697fd5ae7e248ed51b84320e683e121f486f0333388267fe26b82285ebd0aaa",
+        "size_in_bytes": 1107
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "369abafe32a2d3776121c46799bb85870be2549c703b4b5812712158cbfd709a",
+        "sha256_in_prefix": "369abafe32a2d3776121c46799bb85870be2549c703b4b5812712158cbfd709a",
+        "size_in_bytes": 4402
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "367c6fe210a2a212cbe8cb5653055b1347f79474d6d3d8ec108e959425514f60",
+        "sha256_in_prefix": "367c6fe210a2a212cbe8cb5653055b1347f79474d6d3d8ec108e959425514f60",
+        "size_in_bytes": 4572
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/__pycache__/convert.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "b3cc415ed400f14b3676aa06df95266e228aacb0600119ab3af863a3f746c5b8",
+        "sha256_in_prefix": "b3cc415ed400f14b3676aa06df95266e228aacb0600119ab3af863a3f746c5b8",
+        "size_in_bytes": 9446
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/__pycache__/pack.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "14567021e4156c592761e3b8782f35c6b68533a37965d99f229e50868de3b2a7",
+        "sha256_in_prefix": "14567021e4156c592761e3b8782f35c6b68533a37965d99f229e50868de3b2a7",
+        "size_in_bytes": 3072
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/__pycache__/tags.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e4d9f6908d893ae524fc553900b65aba8ba707b4226a319d5b5b7629d1d75a99",
+        "sha256_in_prefix": "e4d9f6908d893ae524fc553900b65aba8ba707b4226a319d5b5b7629d1d75a99",
+        "size_in_bytes": 3785
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/__pycache__/unpack.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "02137fd2f9fe46bf5c68a4c3771fc15f668c294278ff8fe2163236d778ef5d3e",
+        "sha256_in_prefix": "02137fd2f9fe46bf5c68a4c3771fc15f668c294278ff8fe2163236d778ef5d3e",
+        "size_in_bytes": 1043
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/convert.py",
+        "path_type": "hardlink",
+        "sha256": "062d27b445dbf674e5942c56793450e23fa73ecdeccd64842a2a46fc68273244",
+        "sha256_in_prefix": "062d27b445dbf674e5942c56793450e23fa73ecdeccd64842a2a46fc68273244",
+        "size_in_bytes": 12634
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/pack.py",
+        "path_type": "hardlink",
+        "sha256": "08015c1dd055ba5bec1d82659dd2953bb28c23d26a053673e628b43cac7108eb",
+        "sha256_in_prefix": "08015c1dd055ba5bec1d82659dd2953bb28c23d26a053673e628b43cac7108eb",
+        "size_in_bytes": 3103
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/tags.py",
+        "path_type": "hardlink",
+        "sha256": "947c3e2da5ab912e49cbfa96730fbaa528de34ceb20230e7a8a2371392534c25",
+        "sha256_in_prefix": "947c3e2da5ab912e49cbfa96730fbaa528de34ceb20230e7a8a2371392534c25",
+        "size_in_bytes": 4760
+      },
+      {
+        "_path": "Lib/site-packages/wheel/cli/unpack.py",
+        "path_type": "hardlink",
+        "sha256": "63f27bca7c4f4a81454d3ec7d1f3206c195512bc320c670e6e099ee4c06ecf9f",
+        "sha256_in_prefix": "63f27bca7c4f4a81454d3ec7d1f3206c195512bc320c670e6e099ee4c06ecf9f",
+        "size_in_bytes": 1021
+      },
+      {
+        "_path": "Lib/site-packages/wheel/macosx_libfile.py",
+        "path_type": "hardlink",
+        "sha256": "935c7b084dcb3ed3951aa8fa3574359d319854f69e46b855cd41bf28fab7cc3b",
+        "sha256_in_prefix": "935c7b084dcb3ed3951aa8fa3574359d319854f69e46b855cd41bf28fab7cc3b",
+        "size_in_bytes": 16572
+      },
+      {
+        "_path": "Lib/site-packages/wheel/metadata.py",
+        "path_type": "hardlink",
+        "sha256": "242e29ee395066ed9b513010d9f7af92a2e383f5fa8273724612e7e8e50ed6d7",
+        "sha256_in_prefix": "242e29ee395066ed9b513010d9f7af92a2e383f5fa8273724612e7e8e50ed6d7",
+        "size_in_bytes": 6171
+      },
+      {
+        "_path": "Lib/site-packages/wheel/util.py",
+        "path_type": "hardlink",
+        "sha256": "68beda89b1f061481f73c5a5a252f9b577645780dab5b2716476f59301c52405",
+        "sha256_in_prefix": "68beda89b1f061481f73c5a5a252f9b577645780dab5b2716476f59301c52405",
+        "size_in_bytes": 423
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "08856a169b47b06f436a9229bedb2450ffd96d3653d477a3db3e0d67787677f6",
+        "sha256_in_prefix": "08856a169b47b06f436a9229bedb2450ffd96d3653d477a3db3e0d67787677f6",
+        "size_in_bytes": 135
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/LICENSE",
+        "path_type": "hardlink",
+        "sha256": "cad1ef5bd340d73e074ba614d26f7deaca5c7940c3d8c34852e65c4909686c48",
+        "sha256_in_prefix": "cad1ef5bd340d73e074ba614d26f7deaca5c7940c3d8c34852e65c4909686c48",
+        "size_in_bytes": 197
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/LICENSE.APACHE",
+        "path_type": "hardlink",
+        "sha256": "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594",
+        "sha256_in_prefix": "0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594",
+        "size_in_bytes": 10174
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/LICENSE.BSD",
+        "path_type": "hardlink",
+        "sha256": "b70e7e9b742f1cc6f948b34c16aa39ffece94196364bc88ff0d2180f0028fac5",
+        "sha256_in_prefix": "b70e7e9b742f1cc6f948b34c16aa39ffece94196364bc88ff0d2180f0028fac5",
+        "size_in_bytes": 1344
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__init__.py",
+        "path_type": "hardlink",
+        "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "sha256_in_prefix": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "size_in_bytes": 0
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/__init__.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2358c8a324ee232955cd93a9f3fa88ad182dc4f044804dd8294dab71a3adec48",
+        "sha256_in_prefix": "2358c8a324ee232955cd93a9f3fa88ad182dc4f044804dd8294dab71a3adec48",
+        "size_in_bytes": 145
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/_elffile.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ccfa1515d784ce3b0452bd33672c613debdf4a9bc965fc56711935d54ade9f81",
+        "sha256_in_prefix": "ccfa1515d784ce3b0452bd33672c613debdf4a9bc965fc56711935d54ade9f81",
+        "size_in_bytes": 3315
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/_manylinux.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "a240661a3920b72f0221516f3c3bb6176ae240317b7781fe3c0cde2af1d63b53",
+        "sha256_in_prefix": "a240661a3920b72f0221516f3c3bb6176ae240317b7781fe3c0cde2af1d63b53",
+        "size_in_bytes": 6362
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/_musllinux.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "aa8caed93004d4170d587f3790fce7b0f283febe8f2a506da9801fb85f7b86bd",
+        "sha256_in_prefix": "aa8caed93004d4170d587f3790fce7b0f283febe8f2a506da9801fb85f7b86bd",
+        "size_in_bytes": 3277
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/_parser.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "0ce08d996b05b2c3d11ac1f2f5ff6b77d66291635fdc604e51178dada2a124fe",
+        "sha256_in_prefix": "0ce08d996b05b2c3d11ac1f2f5ff6b77d66291635fdc604e51178dada2a124fe",
+        "size_in_bytes": 8946
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/_structures.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "802c7e3fab8db13e592a1052f9ae28fad62df8caad45583d297a7dcd92d9cd10",
+        "sha256_in_prefix": "802c7e3fab8db13e592a1052f9ae28fad62df8caad45583d297a7dcd92d9cd10",
+        "size_in_bytes": 2755
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/_tokenizer.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "ea3be25391f3c91a0dab3ef4b3da4978a2c7a9e7490b34885b2b513a59258446",
+        "sha256_in_prefix": "ea3be25391f3c91a0dab3ef4b3da4978a2c7a9e7490b34885b2b513a59258446",
+        "size_in_bytes": 5652
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/markers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "6d5a437c38b797bacef49e95cd17d054bd95972d3c9faee4ed37df239f85d935",
+        "sha256_in_prefix": "6d5a437c38b797bacef49e95cd17d054bd95972d3c9faee4ed37df239f85d935",
+        "size_in_bytes": 6942
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/requirements.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "e5e3c5e2af7cf5845e762b3ec6c153dff055fc00b4c7764d6432d585292afc4f",
+        "sha256_in_prefix": "e5e3c5e2af7cf5845e762b3ec6c153dff055fc00b4c7764d6432d585292afc4f",
+        "size_in_bytes": 2795
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/specifiers.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "dd18c38c354d4a1817d57ac89d1c69a36088b64c7a8c60ef26dae490d23dfe3b",
+        "sha256_in_prefix": "dd18c38c354d4a1817d57ac89d1c69a36088b64c7a8c60ef26dae490d23dfe3b",
+        "size_in_bytes": 30996
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/tags.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "67acc4e751dc1a9665c8f2678370bb8fed0f31a7be78a930c621b7bf2bc9b03a",
+        "sha256_in_prefix": "67acc4e751dc1a9665c8f2678370bb8fed0f31a7be78a930c621b7bf2bc9b03a",
+        "size_in_bytes": 13837
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/utils.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "2d0464b93e0d7b3729fddfb89a1691413d200e3052f19a6dd692fe6332c7fc18",
+        "sha256_in_prefix": "2d0464b93e0d7b3729fddfb89a1691413d200e3052f19a6dd692fe6332c7fc18",
+        "size_in_bytes": 4553
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/__pycache__/version.cpython-39.pyc",
+        "path_type": "hardlink",
+        "sha256": "74c1d60e4d39fe93c9f0fd62b252e35ae7f6fe4c53e5d81189f555e36e6e1450",
+        "sha256_in_prefix": "74c1d60e4d39fe93c9f0fd62b252e35ae7f6fe4c53e5d81189f555e36e6e1450",
+        "size_in_bytes": 14273
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/_elffile.py",
+        "path_type": "hardlink",
+        "sha256": "85b98af0e0fa67b7d8ea1c229c7114703d5bcbb73390688d62eed28671449369",
+        "sha256_in_prefix": "85b98af0e0fa67b7d8ea1c229c7114703d5bcbb73390688d62eed28671449369",
+        "size_in_bytes": 3266
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/_manylinux.py",
+        "path_type": "hardlink",
+        "sha256": "3fbb1d479ffb5c1634f4b55860f8479b274c2482303d75ac878a2593be14ba3e",
+        "sha256_in_prefix": "3fbb1d479ffb5c1634f4b55860f8479b274c2482303d75ac878a2593be14ba3e",
+        "size_in_bytes": 9588
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/_musllinux.py",
+        "path_type": "hardlink",
+        "sha256": "cf5b3c4e8da1434be99ff77e3b68b9ab11b010af1698694bb7777fdba57b35e6",
+        "sha256_in_prefix": "cf5b3c4e8da1434be99ff77e3b68b9ab11b010af1698694bb7777fdba57b35e6",
+        "size_in_bytes": 2674
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/_parser.py",
+        "path_type": "hardlink",
+        "sha256": "e2d4f87a64a5daa4da53b553404d576bda358cc3c2b017b3b18071c8d31437eb",
+        "sha256_in_prefix": "e2d4f87a64a5daa4da53b553404d576bda358cc3c2b017b3b18071c8d31437eb",
+        "size_in_bytes": 10347
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/_structures.py",
+        "path_type": "hardlink",
+        "sha256": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe",
+        "sha256_in_prefix": "ab77953666d62461bf4b40e2b7f4b7028f2a42acffe4f6135c500a0597b9cabe",
+        "size_in_bytes": 1431
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/_tokenizer.py",
+        "path_type": "hardlink",
+        "sha256": "6a50ad6f05e138502614667a050fb0093485a11009db3fb2b087fbfff31327f9",
+        "sha256_in_prefix": "6a50ad6f05e138502614667a050fb0093485a11009db3fb2b087fbfff31327f9",
+        "size_in_bytes": 5292
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/markers.py",
+        "path_type": "hardlink",
+        "sha256": "fd348f2350612583bb069f40cd398743122a1c45576938e60e1f46fb0f2accf0",
+        "sha256_in_prefix": "fd348f2350612583bb069f40cd398743122a1c45576938e60e1f46fb0f2accf0",
+        "size_in_bytes": 8232
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/requirements.py",
+        "path_type": "hardlink",
+        "sha256": "760a01795a6b3eed9813a43c9c67f038f4e30131db45afd918bc978451259fa4",
+        "sha256_in_prefix": "760a01795a6b3eed9813a43c9c67f038f4e30131db45afd918bc978451259fa4",
+        "size_in_bytes": 2933
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/specifiers.py",
+        "path_type": "hardlink",
+        "sha256": "2164add12acb48fef685e5a1002f142f4786bdab3b5c84078ea8958957e63ca1",
+        "sha256_in_prefix": "2164add12acb48fef685e5a1002f142f4786bdab3b5c84078ea8958957e63ca1",
+        "size_in_bytes": 39778
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/tags.py",
+        "path_type": "hardlink",
+        "sha256": "7de7475e2387901c4d6535e8b57bfcb973e630553d69ef93281ba38181e281c0",
+        "sha256_in_prefix": "7de7475e2387901c4d6535e8b57bfcb973e630553d69ef93281ba38181e281c0",
+        "size_in_bytes": 18950
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/utils.py",
+        "path_type": "hardlink",
+        "sha256": "5e07663f7cb1f7ec101058ceecebcc8fd46311fe49951e4714547af6fed243d1",
+        "sha256_in_prefix": "5e07663f7cb1f7ec101058ceecebcc8fd46311fe49951e4714547af6fed243d1",
+        "size_in_bytes": 5268
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/packaging/version.py",
+        "path_type": "hardlink",
+        "sha256": "3c525a6190f1060cb191f6211f7490c38a9f13d202096ad39a2b6fab5e32ddbb",
+        "sha256_in_prefix": "3c525a6190f1060cb191f6211f7490c38a9f13d202096ad39a2b6fab5e32ddbb",
+        "size_in_bytes": 16234
+      },
+      {
+        "_path": "Lib/site-packages/wheel/vendored/vendor.txt",
+        "path_type": "hardlink",
+        "sha256": "67610d8c1d62e69adf7b3f0274cd5276bddce99c6fdab451a253292e60677001",
+        "sha256_in_prefix": "67610d8c1d62e69adf7b3f0274cd5276bddce99c6fdab451a253292e60677001",
+        "size_in_bytes": 16
+      },
+      {
+        "_path": "Lib/site-packages/wheel/wheelfile.py",
+        "path_type": "hardlink",
+        "sha256": "5120adb4d949c1a7f1b79d5860514a1bb8e7c73f1d7e16f2a8064bea331303db",
+        "sha256_in_prefix": "5120adb4d949c1a7f1b79d5860514a1bb8e7c73f1d7e16f2a8064bea331303db",
+        "size_in_bytes": 8411
+      },
+      {
+        "_path": "Scripts/wheel-script.py",
+        "path_type": "hardlink",
+        "sha256": "f81e86d226fd97f3a9fb708b803859f8922740e5b62a4577b0b6b8b1d6b8e333",
+        "sha256_in_prefix": "f81e86d226fd97f3a9fb708b803859f8922740e5b62a4577b0b6b8b1d6b8e333",
+        "size_in_bytes": 203
+      },
+      {
+        "_path": "Scripts/wheel.exe",
+        "path_type": "hardlink",
+        "sha256": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "sha256_in_prefix": "f24d102084620e54fe68d07f6e9169118b283f8d33d0c8f4b974c2e05a306059",
+        "size_in_bytes": 54032
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "9f942101cc076c259ea20fb6f13a58823218e0389b060b766dc4cae37469ae92",
+  "size": 148042,
+  "subdir": "win-64",
+  "timestamp": 1737990404679,
+  "track_features": "",
+  "url": "https://repo.anaconda.com/pkgs/main/win-64/wheel-0.45.1-py39haa95532_0.conda",
+  "version": "0.45.1"
+}
\ No newline at end of file
diff --git a/marketing/etc/conda/activate.d/openssl_activate.bat b/marketing/etc/conda/activate.d/openssl_activate.bat
new file mode 100644
index 0000000000000000000000000000000000000000..69955be09a4d61216cf702f3c2254a869215cfbf
--- /dev/null
+++ b/marketing/etc/conda/activate.d/openssl_activate.bat
@@ -0,0 +1,5 @@
+@echo off
+if "%SSL_CERT_FILE%"=="" (
+    set SSL_CERT_FILE=%CONDA_PREFIX%\Library\ssl\cacert.pem
+    set __CONDA_OPENSLL_CERT_FILE_SET="1"
+)
diff --git a/marketing/etc/conda/activate.d/openssl_activate.ps1 b/marketing/etc/conda/activate.d/openssl_activate.ps1
new file mode 100644
index 0000000000000000000000000000000000000000..41d91f63af4cc9a02c3bbbd6d150c5385b75ad5d
--- /dev/null
+++ b/marketing/etc/conda/activate.d/openssl_activate.ps1
@@ -0,0 +1,4 @@
+if (-not $Env:SSL_CERT_FILE) {
+    $Env:SSL_CERT_FILE = "$Env:CONDA_PREFIX\Library\ssl\cacert.pem"
+    $Env:__CONDA_OPENSLL_CERT_FILE_SET = "1"
+}
diff --git a/marketing/etc/conda/activate.d/openssl_activate.sh b/marketing/etc/conda/activate.d/openssl_activate.sh
new file mode 100644
index 0000000000000000000000000000000000000000..085e919dacf36315fefc9eda68fe9b0b783595cc
--- /dev/null
+++ b/marketing/etc/conda/activate.d/openssl_activate.sh
@@ -0,0 +1,4 @@
+if [[ "${SSL_CERT_FILE:-}" == "" ]]; then
+    export SSL_CERT_FILE="${CONDA_PREFIX}\\Library\ssl\\cacert.pem"
+    export __CONDA_OPENSLL_CERT_FILE_SET="1"
+fi
diff --git a/marketing/etc/conda/deactivate.d/openssl_deactivate.bat b/marketing/etc/conda/deactivate.d/openssl_deactivate.bat
new file mode 100644
index 0000000000000000000000000000000000000000..808a8ac1f5053875d812377640b28d610ec7ccff
--- /dev/null
+++ b/marketing/etc/conda/deactivate.d/openssl_deactivate.bat
@@ -0,0 +1,5 @@
+@echo off
+if "%__CONDA_OPENSLL_CERT_FILE_SET%" == "1" (
+    set SSL_CERT_FILE=
+    set __CONDA_OPENSLL_CERT_FILE_SET=
+)
diff --git a/marketing/etc/conda/deactivate.d/openssl_deactivate.ps1 b/marketing/etc/conda/deactivate.d/openssl_deactivate.ps1
new file mode 100644
index 0000000000000000000000000000000000000000..2fd22a83e04f1533ecf0b0cd26a1daf9ee4e2c67
--- /dev/null
+++ b/marketing/etc/conda/deactivate.d/openssl_deactivate.ps1
@@ -0,0 +1,4 @@
+if ($Env:__CONDA_OPENSLL_CERT_FILE_SET -eq "1") {
+    Remove-Item -Path Env:\SSL_CERT_FILE
+    Remove-Item -Path Env:\__CONDA_OPENSLL_CERT_FILE_SET
+}
diff --git a/marketing/etc/conda/deactivate.d/openssl_deactivate.sh b/marketing/etc/conda/deactivate.d/openssl_deactivate.sh
new file mode 100644
index 0000000000000000000000000000000000000000..058f86c292910a54f447830f2a763f775b7f4d60
--- /dev/null
+++ b/marketing/etc/conda/deactivate.d/openssl_deactivate.sh
@@ -0,0 +1,4 @@
+if [[ "${__CONDA_OPENSLL_CERT_FILE_SET:-}" == "1" ]]; then
+    unset SSL_CERT_FILE
+    unset __CONDA_OPENSLL_CERT_FILE_SET
+fi
diff --git a/marketing/include/Python-ast.h b/marketing/include/Python-ast.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7afa1e6579e8d4c98fee8c4d05cfb4249779a98
--- /dev/null
+++ b/marketing/include/Python-ast.h
@@ -0,0 +1,697 @@
+/* File automatically generated by Parser/asdl_c.py. */
+
+#ifndef Py_PYTHON_AST_H
+#define Py_PYTHON_AST_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+#include "asdl.h"
+
+#undef Yield   /* undefine macro conflicting with  */
+
+typedef struct _mod *mod_ty;
+
+typedef struct _stmt *stmt_ty;
+
+typedef struct _expr *expr_ty;
+
+typedef enum _expr_context { Load=1, Store=2, Del=3 } expr_context_ty;
+
+typedef enum _boolop { And=1, Or=2 } boolop_ty;
+
+typedef enum _operator { Add=1, Sub=2, Mult=3, MatMult=4, Div=5, Mod=6, Pow=7,
+                         LShift=8, RShift=9, BitOr=10, BitXor=11, BitAnd=12,
+                         FloorDiv=13 } operator_ty;
+
+typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty;
+
+typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8,
+                      In=9, NotIn=10 } cmpop_ty;
+
+typedef struct _comprehension *comprehension_ty;
+
+typedef struct _excepthandler *excepthandler_ty;
+
+typedef struct _arguments *arguments_ty;
+
+typedef struct _arg *arg_ty;
+
+typedef struct _keyword *keyword_ty;
+
+typedef struct _alias *alias_ty;
+
+typedef struct _withitem *withitem_ty;
+
+typedef struct _type_ignore *type_ignore_ty;
+
+
+enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3,
+                 FunctionType_kind=4};
+struct _mod {
+    enum _mod_kind kind;
+    union {
+        struct {
+            asdl_seq *body;
+            asdl_seq *type_ignores;
+        } Module;
+
+        struct {
+            asdl_seq *body;
+        } Interactive;
+
+        struct {
+            expr_ty body;
+        } Expression;
+
+        struct {
+            asdl_seq *argtypes;
+            expr_ty returns;
+        } FunctionType;
+
+    } v;
+};
+
+enum _stmt_kind {FunctionDef_kind=1, AsyncFunctionDef_kind=2, ClassDef_kind=3,
+                  Return_kind=4, Delete_kind=5, Assign_kind=6,
+                  AugAssign_kind=7, AnnAssign_kind=8, For_kind=9,
+                  AsyncFor_kind=10, While_kind=11, If_kind=12, With_kind=13,
+                  AsyncWith_kind=14, Raise_kind=15, Try_kind=16,
+                  Assert_kind=17, Import_kind=18, ImportFrom_kind=19,
+                  Global_kind=20, Nonlocal_kind=21, Expr_kind=22, Pass_kind=23,
+                  Break_kind=24, Continue_kind=25};
+struct _stmt {
+    enum _stmt_kind kind;
+    union {
+        struct {
+            identifier name;
+            arguments_ty args;
+            asdl_seq *body;
+            asdl_seq *decorator_list;
+            expr_ty returns;
+            string type_comment;
+        } FunctionDef;
+
+        struct {
+            identifier name;
+            arguments_ty args;
+            asdl_seq *body;
+            asdl_seq *decorator_list;
+            expr_ty returns;
+            string type_comment;
+        } AsyncFunctionDef;
+
+        struct {
+            identifier name;
+            asdl_seq *bases;
+            asdl_seq *keywords;
+            asdl_seq *body;
+            asdl_seq *decorator_list;
+        } ClassDef;
+
+        struct {
+            expr_ty value;
+        } Return;
+
+        struct {
+            asdl_seq *targets;
+        } Delete;
+
+        struct {
+            asdl_seq *targets;
+            expr_ty value;
+            string type_comment;
+        } Assign;
+
+        struct {
+            expr_ty target;
+            operator_ty op;
+            expr_ty value;
+        } AugAssign;
+
+        struct {
+            expr_ty target;
+            expr_ty annotation;
+            expr_ty value;
+            int simple;
+        } AnnAssign;
+
+        struct {
+            expr_ty target;
+            expr_ty iter;
+            asdl_seq *body;
+            asdl_seq *orelse;
+            string type_comment;
+        } For;
+
+        struct {
+            expr_ty target;
+            expr_ty iter;
+            asdl_seq *body;
+            asdl_seq *orelse;
+            string type_comment;
+        } AsyncFor;
+
+        struct {
+            expr_ty test;
+            asdl_seq *body;
+            asdl_seq *orelse;
+        } While;
+
+        struct {
+            expr_ty test;
+            asdl_seq *body;
+            asdl_seq *orelse;
+        } If;
+
+        struct {
+            asdl_seq *items;
+            asdl_seq *body;
+            string type_comment;
+        } With;
+
+        struct {
+            asdl_seq *items;
+            asdl_seq *body;
+            string type_comment;
+        } AsyncWith;
+
+        struct {
+            expr_ty exc;
+            expr_ty cause;
+        } Raise;
+
+        struct {
+            asdl_seq *body;
+            asdl_seq *handlers;
+            asdl_seq *orelse;
+            asdl_seq *finalbody;
+        } Try;
+
+        struct {
+            expr_ty test;
+            expr_ty msg;
+        } Assert;
+
+        struct {
+            asdl_seq *names;
+        } Import;
+
+        struct {
+            identifier module;
+            asdl_seq *names;
+            int level;
+        } ImportFrom;
+
+        struct {
+            asdl_seq *names;
+        } Global;
+
+        struct {
+            asdl_seq *names;
+        } Nonlocal;
+
+        struct {
+            expr_ty value;
+        } Expr;
+
+    } v;
+    int lineno;
+    int col_offset;
+    int end_lineno;
+    int end_col_offset;
+};
+
+enum _expr_kind {BoolOp_kind=1, NamedExpr_kind=2, BinOp_kind=3, UnaryOp_kind=4,
+                  Lambda_kind=5, IfExp_kind=6, Dict_kind=7, Set_kind=8,
+                  ListComp_kind=9, SetComp_kind=10, DictComp_kind=11,
+                  GeneratorExp_kind=12, Await_kind=13, Yield_kind=14,
+                  YieldFrom_kind=15, Compare_kind=16, Call_kind=17,
+                  FormattedValue_kind=18, JoinedStr_kind=19, Constant_kind=20,
+                  Attribute_kind=21, Subscript_kind=22, Starred_kind=23,
+                  Name_kind=24, List_kind=25, Tuple_kind=26, Slice_kind=27};
+struct _expr {
+    enum _expr_kind kind;
+    union {
+        struct {
+            boolop_ty op;
+            asdl_seq *values;
+        } BoolOp;
+
+        struct {
+            expr_ty target;
+            expr_ty value;
+        } NamedExpr;
+
+        struct {
+            expr_ty left;
+            operator_ty op;
+            expr_ty right;
+        } BinOp;
+
+        struct {
+            unaryop_ty op;
+            expr_ty operand;
+        } UnaryOp;
+
+        struct {
+            arguments_ty args;
+            expr_ty body;
+        } Lambda;
+
+        struct {
+            expr_ty test;
+            expr_ty body;
+            expr_ty orelse;
+        } IfExp;
+
+        struct {
+            asdl_seq *keys;
+            asdl_seq *values;
+        } Dict;
+
+        struct {
+            asdl_seq *elts;
+        } Set;
+
+        struct {
+            expr_ty elt;
+            asdl_seq *generators;
+        } ListComp;
+
+        struct {
+            expr_ty elt;
+            asdl_seq *generators;
+        } SetComp;
+
+        struct {
+            expr_ty key;
+            expr_ty value;
+            asdl_seq *generators;
+        } DictComp;
+
+        struct {
+            expr_ty elt;
+            asdl_seq *generators;
+        } GeneratorExp;
+
+        struct {
+            expr_ty value;
+        } Await;
+
+        struct {
+            expr_ty value;
+        } Yield;
+
+        struct {
+            expr_ty value;
+        } YieldFrom;
+
+        struct {
+            expr_ty left;
+            asdl_int_seq *ops;
+            asdl_seq *comparators;
+        } Compare;
+
+        struct {
+            expr_ty func;
+            asdl_seq *args;
+            asdl_seq *keywords;
+        } Call;
+
+        struct {
+            expr_ty value;
+            int conversion;
+            expr_ty format_spec;
+        } FormattedValue;
+
+        struct {
+            asdl_seq *values;
+        } JoinedStr;
+
+        struct {
+            constant value;
+            string kind;
+        } Constant;
+
+        struct {
+            expr_ty value;
+            identifier attr;
+            expr_context_ty ctx;
+        } Attribute;
+
+        struct {
+            expr_ty value;
+            expr_ty slice;
+            expr_context_ty ctx;
+        } Subscript;
+
+        struct {
+            expr_ty value;
+            expr_context_ty ctx;
+        } Starred;
+
+        struct {
+            identifier id;
+            expr_context_ty ctx;
+        } Name;
+
+        struct {
+            asdl_seq *elts;
+            expr_context_ty ctx;
+        } List;
+
+        struct {
+            asdl_seq *elts;
+            expr_context_ty ctx;
+        } Tuple;
+
+        struct {
+            expr_ty lower;
+            expr_ty upper;
+            expr_ty step;
+        } Slice;
+
+    } v;
+    int lineno;
+    int col_offset;
+    int end_lineno;
+    int end_col_offset;
+};
+
+struct _comprehension {
+    expr_ty target;
+    expr_ty iter;
+    asdl_seq *ifs;
+    int is_async;
+};
+
+enum _excepthandler_kind {ExceptHandler_kind=1};
+struct _excepthandler {
+    enum _excepthandler_kind kind;
+    union {
+        struct {
+            expr_ty type;
+            identifier name;
+            asdl_seq *body;
+        } ExceptHandler;
+
+    } v;
+    int lineno;
+    int col_offset;
+    int end_lineno;
+    int end_col_offset;
+};
+
+struct _arguments {
+    asdl_seq *posonlyargs;
+    asdl_seq *args;
+    arg_ty vararg;
+    asdl_seq *kwonlyargs;
+    asdl_seq *kw_defaults;
+    arg_ty kwarg;
+    asdl_seq *defaults;
+};
+
+struct _arg {
+    identifier arg;
+    expr_ty annotation;
+    string type_comment;
+    int lineno;
+    int col_offset;
+    int end_lineno;
+    int end_col_offset;
+};
+
+struct _keyword {
+    identifier arg;
+    expr_ty value;
+    int lineno;
+    int col_offset;
+    int end_lineno;
+    int end_col_offset;
+};
+
+struct _alias {
+    identifier name;
+    identifier asname;
+};
+
+struct _withitem {
+    expr_ty context_expr;
+    expr_ty optional_vars;
+};
+
+enum _type_ignore_kind {TypeIgnore_kind=1};
+struct _type_ignore {
+    enum _type_ignore_kind kind;
+    union {
+        struct {
+            int lineno;
+            string tag;
+        } TypeIgnore;
+
+    } v;
+};
+
+
+// Note: these macros affect function definitions, not only call sites.
+#define Module(a0, a1, a2) _Py_Module(a0, a1, a2)
+mod_ty _Py_Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena);
+#define Interactive(a0, a1) _Py_Interactive(a0, a1)
+mod_ty _Py_Interactive(asdl_seq * body, PyArena *arena);
+#define Expression(a0, a1) _Py_Expression(a0, a1)
+mod_ty _Py_Expression(expr_ty body, PyArena *arena);
+#define FunctionType(a0, a1, a2) _Py_FunctionType(a0, a1, a2)
+mod_ty _Py_FunctionType(asdl_seq * argtypes, expr_ty returns, PyArena *arena);
+#define FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) _Py_FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
+stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body,
+                        asdl_seq * decorator_list, expr_ty returns, string
+                        type_comment, int lineno, int col_offset, int
+                        end_lineno, int end_col_offset, PyArena *arena);
+#define AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) _Py_AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
+stmt_ty _Py_AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq *
+                             body, asdl_seq * decorator_list, expr_ty returns,
+                             string type_comment, int lineno, int col_offset,
+                             int end_lineno, int end_col_offset, PyArena
+                             *arena);
+#define ClassDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
+stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords,
+                     asdl_seq * body, asdl_seq * decorator_list, int lineno,
+                     int col_offset, int end_lineno, int end_col_offset,
+                     PyArena *arena);
+#define Return(a0, a1, a2, a3, a4, a5) _Py_Return(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, int end_lineno,
+                   int end_col_offset, PyArena *arena);
+#define Delete(a0, a1, a2, a3, a4, a5) _Py_Delete(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_Delete(asdl_seq * targets, int lineno, int col_offset, int
+                   end_lineno, int end_col_offset, PyArena *arena);
+#define Assign(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Assign(a0, a1, a2, a3, a4, a5, a6, a7)
+stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, string type_comment, int
+                   lineno, int col_offset, int end_lineno, int end_col_offset,
+                   PyArena *arena);
+#define AugAssign(a0, a1, a2, a3, a4, a5, a6, a7) _Py_AugAssign(a0, a1, a2, a3, a4, a5, a6, a7)
+stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
+                      lineno, int col_offset, int end_lineno, int
+                      end_col_offset, PyArena *arena);
+#define AnnAssign(a0, a1, a2, a3, a4, a5, a6, a7, a8) _Py_AnnAssign(a0, a1, a2, a3, a4, a5, a6, a7, a8)
+stmt_ty _Py_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int
+                      simple, int lineno, int col_offset, int end_lineno, int
+                      end_col_offset, PyArena *arena);
+#define For(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) _Py_For(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
+stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
+                orelse, string type_comment, int lineno, int col_offset, int
+                end_lineno, int end_col_offset, PyArena *arena);
+#define AsyncFor(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) _Py_AsyncFor(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
+stmt_ty _Py_AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
+                     orelse, string type_comment, int lineno, int col_offset,
+                     int end_lineno, int end_col_offset, PyArena *arena);
+#define While(a0, a1, a2, a3, a4, a5, a6, a7) _Py_While(a0, a1, a2, a3, a4, a5, a6, a7)
+stmt_ty _Py_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
+                  int col_offset, int end_lineno, int end_col_offset, PyArena
+                  *arena);
+#define If(a0, a1, a2, a3, a4, a5, a6, a7) _Py_If(a0, a1, a2, a3, a4, a5, a6, a7)
+stmt_ty _Py_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
+               int col_offset, int end_lineno, int end_col_offset, PyArena
+               *arena);
+#define With(a0, a1, a2, a3, a4, a5, a6, a7) _Py_With(a0, a1, a2, a3, a4, a5, a6, a7)
+stmt_ty _Py_With(asdl_seq * items, asdl_seq * body, string type_comment, int
+                 lineno, int col_offset, int end_lineno, int end_col_offset,
+                 PyArena *arena);
+#define AsyncWith(a0, a1, a2, a3, a4, a5, a6, a7) _Py_AsyncWith(a0, a1, a2, a3, a4, a5, a6, a7)
+stmt_ty _Py_AsyncWith(asdl_seq * items, asdl_seq * body, string type_comment,
+                      int lineno, int col_offset, int end_lineno, int
+                      end_col_offset, PyArena *arena);
+#define Raise(a0, a1, a2, a3, a4, a5, a6) _Py_Raise(a0, a1, a2, a3, a4, a5, a6)
+stmt_ty _Py_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, int
+                  end_lineno, int end_col_offset, PyArena *arena);
+#define Try(a0, a1, a2, a3, a4, a5, a6, a7, a8) _Py_Try(a0, a1, a2, a3, a4, a5, a6, a7, a8)
+stmt_ty _Py_Try(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse,
+                asdl_seq * finalbody, int lineno, int col_offset, int
+                end_lineno, int end_col_offset, PyArena *arena);
+#define Assert(a0, a1, a2, a3, a4, a5, a6) _Py_Assert(a0, a1, a2, a3, a4, a5, a6)
+stmt_ty _Py_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, int
+                   end_lineno, int end_col_offset, PyArena *arena);
+#define Import(a0, a1, a2, a3, a4, a5) _Py_Import(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_Import(asdl_seq * names, int lineno, int col_offset, int
+                   end_lineno, int end_col_offset, PyArena *arena);
+#define ImportFrom(a0, a1, a2, a3, a4, a5, a6, a7) _Py_ImportFrom(a0, a1, a2, a3, a4, a5, a6, a7)
+stmt_ty _Py_ImportFrom(identifier module, asdl_seq * names, int level, int
+                       lineno, int col_offset, int end_lineno, int
+                       end_col_offset, PyArena *arena);
+#define Global(a0, a1, a2, a3, a4, a5) _Py_Global(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_Global(asdl_seq * names, int lineno, int col_offset, int
+                   end_lineno, int end_col_offset, PyArena *arena);
+#define Nonlocal(a0, a1, a2, a3, a4, a5) _Py_Nonlocal(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_Nonlocal(asdl_seq * names, int lineno, int col_offset, int
+                     end_lineno, int end_col_offset, PyArena *arena);
+#define Expr(a0, a1, a2, a3, a4, a5) _Py_Expr(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_Expr(expr_ty value, int lineno, int col_offset, int end_lineno, int
+                 end_col_offset, PyArena *arena);
+#define Pass(a0, a1, a2, a3, a4) _Py_Pass(a0, a1, a2, a3, a4)
+stmt_ty _Py_Pass(int lineno, int col_offset, int end_lineno, int
+                 end_col_offset, PyArena *arena);
+#define Break(a0, a1, a2, a3, a4) _Py_Break(a0, a1, a2, a3, a4)
+stmt_ty _Py_Break(int lineno, int col_offset, int end_lineno, int
+                  end_col_offset, PyArena *arena);
+#define Continue(a0, a1, a2, a3, a4) _Py_Continue(a0, a1, a2, a3, a4)
+stmt_ty _Py_Continue(int lineno, int col_offset, int end_lineno, int
+                     end_col_offset, PyArena *arena);
+#define BoolOp(a0, a1, a2, a3, a4, a5, a6) _Py_BoolOp(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset,
+                   int end_lineno, int end_col_offset, PyArena *arena);
+#define NamedExpr(a0, a1, a2, a3, a4, a5, a6) _Py_NamedExpr(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_NamedExpr(expr_ty target, expr_ty value, int lineno, int
+                      col_offset, int end_lineno, int end_col_offset, PyArena
+                      *arena);
+#define BinOp(a0, a1, a2, a3, a4, a5, a6, a7) _Py_BinOp(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int
+                  col_offset, int end_lineno, int end_col_offset, PyArena
+                  *arena);
+#define UnaryOp(a0, a1, a2, a3, a4, a5, a6) _Py_UnaryOp(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset,
+                    int end_lineno, int end_col_offset, PyArena *arena);
+#define Lambda(a0, a1, a2, a3, a4, a5, a6) _Py_Lambda(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset,
+                   int end_lineno, int end_col_offset, PyArena *arena);
+#define IfExp(a0, a1, a2, a3, a4, a5, a6, a7) _Py_IfExp(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
+                  col_offset, int end_lineno, int end_col_offset, PyArena
+                  *arena);
+#define Dict(a0, a1, a2, a3, a4, a5, a6) _Py_Dict(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int
+                 col_offset, int end_lineno, int end_col_offset, PyArena
+                 *arena);
+#define Set(a0, a1, a2, a3, a4, a5) _Py_Set(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_Set(asdl_seq * elts, int lineno, int col_offset, int end_lineno,
+                int end_col_offset, PyArena *arena);
+#define ListComp(a0, a1, a2, a3, a4, a5, a6) _Py_ListComp(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int
+                     col_offset, int end_lineno, int end_col_offset, PyArena
+                     *arena);
+#define SetComp(a0, a1, a2, a3, a4, a5, a6) _Py_SetComp(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_SetComp(expr_ty elt, asdl_seq * generators, int lineno, int
+                    col_offset, int end_lineno, int end_col_offset, PyArena
+                    *arena);
+#define DictComp(a0, a1, a2, a3, a4, a5, a6, a7) _Py_DictComp(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int
+                     lineno, int col_offset, int end_lineno, int
+                     end_col_offset, PyArena *arena);
+#define GeneratorExp(a0, a1, a2, a3, a4, a5, a6) _Py_GeneratorExp(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int
+                         col_offset, int end_lineno, int end_col_offset,
+                         PyArena *arena);
+#define Await(a0, a1, a2, a3, a4, a5) _Py_Await(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_Await(expr_ty value, int lineno, int col_offset, int end_lineno,
+                  int end_col_offset, PyArena *arena);
+#define Yield(a0, a1, a2, a3, a4, a5) _Py_Yield(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_Yield(expr_ty value, int lineno, int col_offset, int end_lineno,
+                  int end_col_offset, PyArena *arena);
+#define YieldFrom(a0, a1, a2, a3, a4, a5) _Py_YieldFrom(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_YieldFrom(expr_ty value, int lineno, int col_offset, int
+                      end_lineno, int end_col_offset, PyArena *arena);
+#define Compare(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Compare(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators,
+                    int lineno, int col_offset, int end_lineno, int
+                    end_col_offset, PyArena *arena);
+#define Call(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Call(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int
+                 lineno, int col_offset, int end_lineno, int end_col_offset,
+                 PyArena *arena);
+#define FormattedValue(a0, a1, a2, a3, a4, a5, a6, a7) _Py_FormattedValue(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_FormattedValue(expr_ty value, int conversion, expr_ty format_spec,
+                           int lineno, int col_offset, int end_lineno, int
+                           end_col_offset, PyArena *arena);
+#define JoinedStr(a0, a1, a2, a3, a4, a5) _Py_JoinedStr(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_JoinedStr(asdl_seq * values, int lineno, int col_offset, int
+                      end_lineno, int end_col_offset, PyArena *arena);
+#define Constant(a0, a1, a2, a3, a4, a5, a6) _Py_Constant(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_Constant(constant value, string kind, int lineno, int col_offset,
+                     int end_lineno, int end_col_offset, PyArena *arena);
+#define Attribute(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Attribute(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int
+                      lineno, int col_offset, int end_lineno, int
+                      end_col_offset, PyArena *arena);
+#define Subscript(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Subscript(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_Subscript(expr_ty value, expr_ty slice, expr_context_ty ctx, int
+                      lineno, int col_offset, int end_lineno, int
+                      end_col_offset, PyArena *arena);
+#define Starred(a0, a1, a2, a3, a4, a5, a6) _Py_Starred(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_Starred(expr_ty value, expr_context_ty ctx, int lineno, int
+                    col_offset, int end_lineno, int end_col_offset, PyArena
+                    *arena);
+#define Name(a0, a1, a2, a3, a4, a5, a6) _Py_Name(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_Name(identifier id, expr_context_ty ctx, int lineno, int
+                 col_offset, int end_lineno, int end_col_offset, PyArena
+                 *arena);
+#define List(a0, a1, a2, a3, a4, a5, a6) _Py_List(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int
+                 col_offset, int end_lineno, int end_col_offset, PyArena
+                 *arena);
+#define Tuple(a0, a1, a2, a3, a4, a5, a6) _Py_Tuple(a0, a1, a2, a3, a4, a5, a6)
+expr_ty _Py_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int
+                  col_offset, int end_lineno, int end_col_offset, PyArena
+                  *arena);
+#define Slice(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Slice(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, int
+                  col_offset, int end_lineno, int end_col_offset, PyArena
+                  *arena);
+#define comprehension(a0, a1, a2, a3, a4) _Py_comprehension(a0, a1, a2, a3, a4)
+comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_seq *
+                                   ifs, int is_async, PyArena *arena);
+#define ExceptHandler(a0, a1, a2, a3, a4, a5, a6, a7) _Py_ExceptHandler(a0, a1, a2, a3, a4, a5, a6, a7)
+excepthandler_ty _Py_ExceptHandler(expr_ty type, identifier name, asdl_seq *
+                                   body, int lineno, int col_offset, int
+                                   end_lineno, int end_col_offset, PyArena
+                                   *arena);
+#define arguments(a0, a1, a2, a3, a4, a5, a6, a7) _Py_arguments(a0, a1, a2, a3, a4, a5, a6, a7)
+arguments_ty _Py_arguments(asdl_seq * posonlyargs, asdl_seq * args, arg_ty
+                           vararg, asdl_seq * kwonlyargs, asdl_seq *
+                           kw_defaults, arg_ty kwarg, asdl_seq * defaults,
+                           PyArena *arena);
+#define arg(a0, a1, a2, a3, a4, a5, a6, a7) _Py_arg(a0, a1, a2, a3, a4, a5, a6, a7)
+arg_ty _Py_arg(identifier arg, expr_ty annotation, string type_comment, int
+               lineno, int col_offset, int end_lineno, int end_col_offset,
+               PyArena *arena);
+#define keyword(a0, a1, a2, a3, a4, a5, a6) _Py_keyword(a0, a1, a2, a3, a4, a5, a6)
+keyword_ty _Py_keyword(identifier arg, expr_ty value, int lineno, int
+                       col_offset, int end_lineno, int end_col_offset, PyArena
+                       *arena);
+#define alias(a0, a1, a2) _Py_alias(a0, a1, a2)
+alias_ty _Py_alias(identifier name, identifier asname, PyArena *arena);
+#define withitem(a0, a1, a2) _Py_withitem(a0, a1, a2)
+withitem_ty _Py_withitem(expr_ty context_expr, expr_ty optional_vars, PyArena
+                         *arena);
+#define TypeIgnore(a0, a1, a2) _Py_TypeIgnore(a0, a1, a2)
+type_ignore_ty _Py_TypeIgnore(int lineno, string tag, PyArena *arena);
+
+PyObject* PyAST_mod2obj(mod_ty t);
+mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode);
+int PyAST_Check(PyObject* obj);
+#endif /* !Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PYTHON_AST_H */
diff --git a/marketing/include/Python.h b/marketing/include/Python.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f7ed5981c5c77dcc7bca11786f20026e4dcb5c3
--- /dev/null
+++ b/marketing/include/Python.h
@@ -0,0 +1,158 @@
+#ifndef Py_PYTHON_H
+#define Py_PYTHON_H
+/* Since this is a "meta-include" file, no #ifdef __cplusplus / extern "C" { */
+
+/* Include nearly all Python header files */
+
+#include "patchlevel.h"
+#include "pyconfig.h"
+#include "pymacconfig.h"
+
+#include 
+
+#ifndef UCHAR_MAX
+#error "Something's broken.  UCHAR_MAX should be defined in limits.h."
+#endif
+
+#if UCHAR_MAX != 255
+#error "Python's source code assumes C's unsigned char is an 8-bit type."
+#endif
+
+#if defined(__sgi) && !defined(_SGI_MP_SOURCE)
+#define _SGI_MP_SOURCE
+#endif
+
+#include 
+#ifndef NULL
+#   error "Python.h requires that stdio.h define NULL."
+#endif
+
+#include 
+#ifdef HAVE_ERRNO_H
+#include 
+#endif
+#include 
+#ifndef MS_WINDOWS
+#include 
+#endif
+
+/* For size_t? */
+#ifdef HAVE_STDDEF_H
+#include 
+#endif
+
+/* CAUTION:  Build setups should ensure that NDEBUG is defined on the
+ * compiler command line when building Python in release mode; else
+ * assert() calls won't be removed.
+ */
+#include 
+
+#include "pyport.h"
+#include "pymacro.h"
+
+/* A convenient way for code to know if sanitizers are enabled. */
+#if defined(__has_feature)
+#  if __has_feature(memory_sanitizer)
+#    if !defined(_Py_MEMORY_SANITIZER)
+#      define _Py_MEMORY_SANITIZER
+#    endif
+#  endif
+#  if __has_feature(address_sanitizer)
+#    if !defined(_Py_ADDRESS_SANITIZER)
+#      define _Py_ADDRESS_SANITIZER
+#    endif
+#  endif
+#elif defined(__GNUC__)
+#  if defined(__SANITIZE_ADDRESS__)
+#    define _Py_ADDRESS_SANITIZER
+#  endif
+#endif
+
+/* Debug-mode build with pymalloc implies PYMALLOC_DEBUG.
+ *  PYMALLOC_DEBUG is in error if pymalloc is not in use.
+ */
+#if defined(Py_DEBUG) && defined(WITH_PYMALLOC) && !defined(PYMALLOC_DEBUG)
+#define PYMALLOC_DEBUG
+#endif
+#if defined(PYMALLOC_DEBUG) && !defined(WITH_PYMALLOC)
+#error "PYMALLOC_DEBUG requires WITH_PYMALLOC"
+#endif
+#include "pymath.h"
+#include "pytime.h"
+#include "pymem.h"
+
+#include "object.h"
+#include "objimpl.h"
+#include "typeslots.h"
+#include "pyhash.h"
+
+#include "pydebug.h"
+
+#include "bytearrayobject.h"
+#include "bytesobject.h"
+#include "unicodeobject.h"
+#include "longobject.h"
+#include "longintrepr.h"
+#include "boolobject.h"
+#include "floatobject.h"
+#include "complexobject.h"
+#include "rangeobject.h"
+#include "memoryobject.h"
+#include "tupleobject.h"
+#include "listobject.h"
+#include "dictobject.h"
+#include "odictobject.h"
+#include "enumobject.h"
+#include "setobject.h"
+#include "methodobject.h"
+#include "moduleobject.h"
+#include "funcobject.h"
+#include "classobject.h"
+#include "fileobject.h"
+#include "pycapsule.h"
+#include "code.h"
+#include "pyframe.h"
+#include "traceback.h"
+#include "sliceobject.h"
+#include "cellobject.h"
+#include "iterobject.h"
+#include "cpython/initconfig.h"
+#include "genobject.h"
+#include "descrobject.h"
+#include "genericaliasobject.h"
+#include "warnings.h"
+#include "weakrefobject.h"
+#include "structseq.h"
+#include "namespaceobject.h"
+#include "picklebufobject.h"
+
+#include "codecs.h"
+#include "pyerrors.h"
+#include "pythread.h"
+#include "pystate.h"
+#include "context.h"
+
+#include "pyarena.h"
+#include "modsupport.h"
+#include "compile.h"
+#include "pythonrun.h"
+#include "pylifecycle.h"
+#include "ceval.h"
+#include "sysmodule.h"
+#include "osmodule.h"
+#include "intrcheck.h"
+#include "import.h"
+
+#include "abstract.h"
+#include "bltinmodule.h"
+
+#include "eval.h"
+
+#include "pyctype.h"
+#include "pystrtod.h"
+#include "pystrcmp.h"
+#include "fileutils.h"
+#include "pyfpe.h"
+#include "tracemalloc.h"
+
+#endif /* !Py_PYTHON_H */
diff --git a/marketing/include/abstract.h b/marketing/include/abstract.h
new file mode 100644
index 0000000000000000000000000000000000000000..d31d66e6b4aea36ea13caba974dfa7de85833dd1
--- /dev/null
+++ b/marketing/include/abstract.h
@@ -0,0 +1,850 @@
+/* Abstract Object Interface (many thanks to Jim Fulton) */
+
+#ifndef Py_ABSTRACTOBJECT_H
+#define Py_ABSTRACTOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === Object Protocol ================================================== */
+
+/* Implemented elsewhere:
+
+   int PyObject_Print(PyObject *o, FILE *fp, int flags);
+
+   Print an object 'o' on file 'fp'.  Returns -1 on error. The flags argument
+   is used to enable certain printing options. The only option currently
+   supported is Py_Print_RAW.
+
+   (What should be said about Py_Print_RAW?). */
+
+
+/* Implemented elsewhere:
+
+   int PyObject_HasAttrString(PyObject *o, const char *attr_name);
+
+   Returns 1 if object 'o' has the attribute attr_name, and 0 otherwise.
+
+   This is equivalent to the Python expression: hasattr(o,attr_name).
+
+   This function always succeeds. */
+
+
+/* Implemented elsewhere:
+
+   PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name);
+
+   Retrieve an attributed named attr_name form object o.
+   Returns the attribute value on success, or NULL on failure.
+
+   This is the equivalent of the Python expression: o.attr_name. */
+
+
+/* Implemented elsewhere:
+
+   int PyObject_HasAttr(PyObject *o, PyObject *attr_name);
+
+   Returns 1 if o has the attribute attr_name, and 0 otherwise.
+
+   This is equivalent to the Python expression: hasattr(o,attr_name).
+
+   This function always succeeds. */
+
+/* Implemented elsewhere:
+
+   PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name);
+
+   Retrieve an attributed named 'attr_name' form object 'o'.
+   Returns the attribute value on success, or NULL on failure.
+
+   This is the equivalent of the Python expression: o.attr_name. */
+
+
+/* Implemented elsewhere:
+
+   int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v);
+
+   Set the value of the attribute named attr_name, for object 'o',
+   to the value 'v'. Raise an exception and return -1 on failure; return 0 on
+   success.
+
+   This is the equivalent of the Python statement o.attr_name=v. */
+
+
+/* Implemented elsewhere:
+
+   int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v);
+
+   Set the value of the attribute named attr_name, for object 'o', to the value
+   'v'. an exception and return -1 on failure; return 0 on success.
+
+   This is the equivalent of the Python statement o.attr_name=v. */
+
+/* Implemented as a macro:
+
+   int PyObject_DelAttrString(PyObject *o, const char *attr_name);
+
+   Delete attribute named attr_name, for object o. Returns
+   -1 on failure.
+
+   This is the equivalent of the Python statement: del o.attr_name. */
+#define PyObject_DelAttrString(O,A) PyObject_SetAttrString((O),(A), NULL)
+
+
+/* Implemented as a macro:
+
+   int PyObject_DelAttr(PyObject *o, PyObject *attr_name);
+
+   Delete attribute named attr_name, for object o. Returns -1
+   on failure.  This is the equivalent of the Python
+   statement: del o.attr_name. */
+#define  PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A), NULL)
+
+
+/* Implemented elsewhere:
+
+   PyObject *PyObject_Repr(PyObject *o);
+
+   Compute the string representation of object 'o'.  Returns the
+   string representation on success, NULL on failure.
+
+   This is the equivalent of the Python expression: repr(o).
+
+   Called by the repr() built-in function. */
+
+
+/* Implemented elsewhere:
+
+   PyObject *PyObject_Str(PyObject *o);
+
+   Compute the string representation of object, o.  Returns the
+   string representation on success, NULL on failure.
+
+   This is the equivalent of the Python expression: str(o).
+
+   Called by the str() and print() built-in functions. */
+
+
+/* Declared elsewhere
+
+   PyAPI_FUNC(int) PyCallable_Check(PyObject *o);
+
+   Determine if the object, o, is callable.  Return 1 if the object is callable
+   and 0 otherwise.
+
+   This function always succeeds. */
+
+
+#ifdef PY_SSIZE_T_CLEAN
+#  define PyObject_CallFunction _PyObject_CallFunction_SizeT
+#  define PyObject_CallMethod _PyObject_CallMethod_SizeT
+#endif
+
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
+/* Call a callable Python object without any arguments */
+PyAPI_FUNC(PyObject *) PyObject_CallNoArgs(PyObject *func);
+#endif
+
+
+/* Call a callable Python object 'callable' with arguments given by the
+   tuple 'args' and keywords arguments given by the dictionary 'kwargs'.
+
+   'args' must not be NULL, use an empty tuple if no arguments are
+   needed. If no named arguments are needed, 'kwargs' can be NULL.
+
+   This is the equivalent of the Python expression:
+   callable(*args, **kwargs). */
+PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable,
+                                     PyObject *args, PyObject *kwargs);
+
+
+/* Call a callable Python object 'callable', with arguments given by the
+   tuple 'args'.  If no arguments are needed, then 'args' can be NULL.
+
+   Returns the result of the call on success, or NULL on failure.
+
+   This is the equivalent of the Python expression:
+   callable(*args). */
+PyAPI_FUNC(PyObject *) PyObject_CallObject(PyObject *callable,
+                                           PyObject *args);
+
+/* Call a callable Python object, callable, with a variable number of C
+   arguments. The C arguments are described using a mkvalue-style format
+   string.
+
+   The format may be NULL, indicating that no arguments are provided.
+
+   Returns the result of the call on success, or NULL on failure.
+
+   This is the equivalent of the Python expression:
+   callable(arg1, arg2, ...). */
+PyAPI_FUNC(PyObject *) PyObject_CallFunction(PyObject *callable,
+                                             const char *format, ...);
+
+/* Call the method named 'name' of object 'obj' with a variable number of
+   C arguments.  The C arguments are described by a mkvalue format string.
+
+   The format can be NULL, indicating that no arguments are provided.
+
+   Returns the result of the call on success, or NULL on failure.
+
+   This is the equivalent of the Python expression:
+   obj.name(arg1, arg2, ...). */
+PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *obj,
+                                           const char *name,
+                                           const char *format, ...);
+
+PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable,
+                                                    const char *format,
+                                                    ...);
+
+PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *obj,
+                                                  const char *name,
+                                                  const char *format,
+                                                  ...);
+
+/* Call a callable Python object 'callable' with a variable number of C
+   arguments. The C arguments are provided as PyObject* values, terminated
+   by a NULL.
+
+   Returns the result of the call on success, or NULL on failure.
+
+   This is the equivalent of the Python expression:
+   callable(arg1, arg2, ...). */
+PyAPI_FUNC(PyObject *) PyObject_CallFunctionObjArgs(PyObject *callable,
+                                                    ...);
+
+/* Call the method named 'name' of object 'obj' with a variable number of
+   C arguments.  The C arguments are provided as PyObject* values, terminated
+   by NULL.
+
+   Returns the result of the call on success, or NULL on failure.
+
+   This is the equivalent of the Python expression: obj.name(*args). */
+
+PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs(
+    PyObject *obj,
+    PyObject *name,
+    ...);
+
+
+/* Implemented elsewhere:
+
+   Py_hash_t PyObject_Hash(PyObject *o);
+
+   Compute and return the hash, hash_value, of an object, o.  On
+   failure, return -1.
+
+   This is the equivalent of the Python expression: hash(o). */
+
+
+/* Implemented elsewhere:
+
+   int PyObject_IsTrue(PyObject *o);
+
+   Returns 1 if the object, o, is considered to be true, 0 if o is
+   considered to be false and -1 on failure.
+
+   This is equivalent to the Python expression: not not o. */
+
+
+/* Implemented elsewhere:
+
+   int PyObject_Not(PyObject *o);
+
+   Returns 0 if the object, o, is considered to be true, 1 if o is
+   considered to be false and -1 on failure.
+
+   This is equivalent to the Python expression: not o. */
+
+
+/* Get the type of an object.
+
+   On success, returns a type object corresponding to the object type of object
+   'o'. On failure, returns NULL.
+
+   This is equivalent to the Python expression: type(o) */
+PyAPI_FUNC(PyObject *) PyObject_Type(PyObject *o);
+
+
+/* Return the size of object 'o'.  If the object 'o' provides both sequence and
+   mapping protocols, the sequence size is returned.
+
+   On error, -1 is returned.
+
+   This is the equivalent to the Python expression: len(o) */
+PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o);
+
+
+/* For DLL compatibility */
+#undef PyObject_Length
+PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject *o);
+#define PyObject_Length PyObject_Size
+
+/* Return element of 'o' corresponding to the object 'key'. Return NULL
+  on failure.
+
+  This is the equivalent of the Python expression: o[key] */
+PyAPI_FUNC(PyObject *) PyObject_GetItem(PyObject *o, PyObject *key);
+
+
+/* Map the object 'key' to the value 'v' into 'o'.
+
+   Raise an exception and return -1 on failure; return 0 on success.
+
+   This is the equivalent of the Python statement: o[key]=v. */
+PyAPI_FUNC(int) PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v);
+
+/* Remove the mapping for the string 'key' from the object 'o'.
+   Returns -1 on failure.
+
+   This is equivalent to the Python statement: del o[key]. */
+PyAPI_FUNC(int) PyObject_DelItemString(PyObject *o, const char *key);
+
+/* Delete the mapping for the object 'key' from the object 'o'.
+   Returns -1 on failure.
+
+   This is the equivalent of the Python statement: del o[key]. */
+PyAPI_FUNC(int) PyObject_DelItem(PyObject *o, PyObject *key);
+
+
+/* === Old Buffer API ============================================ */
+
+/* FIXME:  usage of these should all be replaced in Python itself
+   but for backwards compatibility we will implement them.
+   Their usage without a corresponding "unlock" mechanism
+   may create issues (but they would already be there). */
+
+/* Takes an arbitrary object which must support the (character, single segment)
+   buffer interface and returns a pointer to a read-only memory location
+   usable as character based input for subsequent processing.
+
+   Return 0 on success.  buffer and buffer_len are only set in case no error
+   occurs. Otherwise, -1 is returned and an exception set. */
+Py_DEPRECATED(3.0)
+PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj,
+                                      const char **buffer,
+                                      Py_ssize_t *buffer_len);
+
+/* Checks whether an arbitrary object supports the (character, single segment)
+   buffer interface.
+
+   Returns 1 on success, 0 on failure. */
+Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj);
+
+/* Same as PyObject_AsCharBuffer() except that this API expects (readable,
+   single segment) buffer interface and returns a pointer to a read-only memory
+   location which can contain arbitrary data.
+
+   0 is returned on success.  buffer and buffer_len are only set in case no
+   error occurs.  Otherwise, -1 is returned and an exception set. */
+Py_DEPRECATED(3.0)
+PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj,
+                                      const void **buffer,
+                                      Py_ssize_t *buffer_len);
+
+/* Takes an arbitrary object which must support the (writable, single segment)
+   buffer interface and returns a pointer to a writable memory location in
+   buffer of size 'buffer_len'.
+
+   Return 0 on success.  buffer and buffer_len are only set in case no error
+   occurs. Otherwise, -1 is returned and an exception set. */
+Py_DEPRECATED(3.0)
+PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj,
+                                       void **buffer,
+                                       Py_ssize_t *buffer_len);
+
+
+/* === New Buffer API ============================================ */
+
+/* Takes an arbitrary object and returns the result of calling
+   obj.__format__(format_spec). */
+PyAPI_FUNC(PyObject *) PyObject_Format(PyObject *obj,
+                                       PyObject *format_spec);
+
+
+/* ==== Iterators ================================================ */
+
+/* Takes an object and returns an iterator for it.
+   This is typically a new iterator but if the argument is an iterator, this
+   returns itself. */
+PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *);
+
+/* Returns 1 if the object 'obj' provides iterator protocols, and 0 otherwise.
+
+   This function always succeeds. */
+PyAPI_FUNC(int) PyIter_Check(PyObject *);
+
+/* Takes an iterator object and calls its tp_iternext slot,
+   returning the next value.
+
+   If the iterator is exhausted, this returns NULL without setting an
+   exception.
+
+   NULL with an exception means an error occurred. */
+PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *);
+
+
+/* === Number Protocol ================================================== */
+
+/* Returns 1 if the object 'o' provides numeric protocols, and 0 otherwise.
+
+   This function always succeeds. */
+PyAPI_FUNC(int) PyNumber_Check(PyObject *o);
+
+/* Returns the result of adding o1 and o2, or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 + o2. */
+PyAPI_FUNC(PyObject *) PyNumber_Add(PyObject *o1, PyObject *o2);
+
+/* Returns the result of subtracting o2 from o1, or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 - o2. */
+PyAPI_FUNC(PyObject *) PyNumber_Subtract(PyObject *o1, PyObject *o2);
+
+/* Returns the result of multiplying o1 and o2, or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 * o2. */
+PyAPI_FUNC(PyObject *) PyNumber_Multiply(PyObject *o1, PyObject *o2);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* This is the equivalent of the Python expression: o1 @ o2. */
+PyAPI_FUNC(PyObject *) PyNumber_MatrixMultiply(PyObject *o1, PyObject *o2);
+#endif
+
+/* Returns the result of dividing o1 by o2 giving an integral result,
+   or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 // o2. */
+PyAPI_FUNC(PyObject *) PyNumber_FloorDivide(PyObject *o1, PyObject *o2);
+
+/* Returns the result of dividing o1 by o2 giving a float result, or NULL on
+   failure.
+
+   This is the equivalent of the Python expression: o1 / o2. */
+PyAPI_FUNC(PyObject *) PyNumber_TrueDivide(PyObject *o1, PyObject *o2);
+
+/* Returns the remainder of dividing o1 by o2, or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 % o2. */
+PyAPI_FUNC(PyObject *) PyNumber_Remainder(PyObject *o1, PyObject *o2);
+
+/* See the built-in function divmod.
+
+   Returns NULL on failure.
+
+   This is the equivalent of the Python expression: divmod(o1, o2). */
+PyAPI_FUNC(PyObject *) PyNumber_Divmod(PyObject *o1, PyObject *o2);
+
+/* See the built-in function pow. Returns NULL on failure.
+
+   This is the equivalent of the Python expression: pow(o1, o2, o3),
+   where o3 is optional. */
+PyAPI_FUNC(PyObject *) PyNumber_Power(PyObject *o1, PyObject *o2,
+                                      PyObject *o3);
+
+/* Returns the negation of o on success, or NULL on failure.
+
+ This is the equivalent of the Python expression: -o. */
+PyAPI_FUNC(PyObject *) PyNumber_Negative(PyObject *o);
+
+/* Returns the positive of o on success, or NULL on failure.
+
+   This is the equivalent of the Python expression: +o. */
+PyAPI_FUNC(PyObject *) PyNumber_Positive(PyObject *o);
+
+/* Returns the absolute value of 'o', or NULL on failure.
+
+   This is the equivalent of the Python expression: abs(o). */
+PyAPI_FUNC(PyObject *) PyNumber_Absolute(PyObject *o);
+
+/* Returns the bitwise negation of 'o' on success, or NULL on failure.
+
+   This is the equivalent of the Python expression: ~o. */
+PyAPI_FUNC(PyObject *) PyNumber_Invert(PyObject *o);
+
+/* Returns the result of left shifting o1 by o2 on success, or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 << o2. */
+PyAPI_FUNC(PyObject *) PyNumber_Lshift(PyObject *o1, PyObject *o2);
+
+/* Returns the result of right shifting o1 by o2 on success, or NULL on
+   failure.
+
+   This is the equivalent of the Python expression: o1 >> o2. */
+PyAPI_FUNC(PyObject *) PyNumber_Rshift(PyObject *o1, PyObject *o2);
+
+/* Returns the result of bitwise and of o1 and o2 on success, or NULL on
+   failure.
+
+   This is the equivalent of the Python expression: o1 & o2. */
+PyAPI_FUNC(PyObject *) PyNumber_And(PyObject *o1, PyObject *o2);
+
+/* Returns the bitwise exclusive or of o1 by o2 on success, or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 ^ o2. */
+PyAPI_FUNC(PyObject *) PyNumber_Xor(PyObject *o1, PyObject *o2);
+
+/* Returns the result of bitwise or on o1 and o2 on success, or NULL on
+   failure.
+
+   This is the equivalent of the Python expression: o1 | o2. */
+PyAPI_FUNC(PyObject *) PyNumber_Or(PyObject *o1, PyObject *o2);
+
+/* Returns 1 if obj is an index integer (has the nb_index slot of the
+   tp_as_number structure filled in), and 0 otherwise. */
+PyAPI_FUNC(int) PyIndex_Check(PyObject *);
+
+/* Returns the object 'o' converted to a Python int, or NULL with an exception
+   raised on failure. */
+PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o);
+
+/* Returns the object 'o' converted to Py_ssize_t by going through
+   PyNumber_Index() first.
+
+   If an overflow error occurs while converting the int to Py_ssize_t, then the
+   second argument 'exc' is the error-type to return.  If it is NULL, then the
+   overflow error is cleared and the value is clipped. */
+PyAPI_FUNC(Py_ssize_t) PyNumber_AsSsize_t(PyObject *o, PyObject *exc);
+
+/* Returns the object 'o' converted to an integer object on success, or NULL
+   on failure.
+
+   This is the equivalent of the Python expression: int(o). */
+PyAPI_FUNC(PyObject *) PyNumber_Long(PyObject *o);
+
+/* Returns the object 'o' converted to a float object on success, or NULL
+  on failure.
+
+  This is the equivalent of the Python expression: float(o). */
+PyAPI_FUNC(PyObject *) PyNumber_Float(PyObject *o);
+
+
+/* --- In-place variants of (some of) the above number protocol functions -- */
+
+/* Returns the result of adding o2 to o1, possibly in-place, or NULL
+   on failure.
+
+   This is the equivalent of the Python expression: o1 += o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2);
+
+/* Returns the result of subtracting o2 from o1, possibly in-place or
+   NULL on failure.
+
+   This is the equivalent of the Python expression: o1 -= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2);
+
+/* Returns the result of multiplying o1 by o2, possibly in-place, or NULL on
+   failure.
+
+   This is the equivalent of the Python expression: o1 *= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* This is the equivalent of the Python expression: o1 @= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceMatrixMultiply(PyObject *o1, PyObject *o2);
+#endif
+
+/* Returns the result of dividing o1 by o2 giving an integral result, possibly
+   in-place, or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 /= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceFloorDivide(PyObject *o1,
+                                                   PyObject *o2);
+
+/* Returns the result of dividing o1 by o2 giving a float result, possibly
+   in-place, or null on failure.
+
+   This is the equivalent of the Python expression: o1 /= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceTrueDivide(PyObject *o1,
+                                                  PyObject *o2);
+
+/* Returns the remainder of dividing o1 by o2, possibly in-place, or NULL on
+   failure.
+
+   This is the equivalent of the Python expression: o1 %= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2);
+
+/* Returns the result of raising o1 to the power of o2, possibly in-place,
+   or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 **= o2,
+   or o1 = pow(o1, o2, o3) if o3 is present. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlacePower(PyObject *o1, PyObject *o2,
+                                             PyObject *o3);
+
+/* Returns the result of left shifting o1 by o2, possibly in-place, or NULL
+   on failure.
+
+   This is the equivalent of the Python expression: o1 <<= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2);
+
+/* Returns the result of right shifting o1 by o2, possibly in-place or NULL
+   on failure.
+
+   This is the equivalent of the Python expression: o1 >>= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2);
+
+/* Returns the result of bitwise and of o1 and o2, possibly in-place, or NULL
+   on failure.
+
+   This is the equivalent of the Python expression: o1 &= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2);
+
+/* Returns the bitwise exclusive or of o1 by o2, possibly in-place, or NULL
+   on failure.
+
+   This is the equivalent of the Python expression: o1 ^= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceXor(PyObject *o1, PyObject *o2);
+
+/* Returns the result of bitwise or of o1 and o2, possibly in-place,
+   or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 |= o2. */
+PyAPI_FUNC(PyObject *) PyNumber_InPlaceOr(PyObject *o1, PyObject *o2);
+
+/* Returns the integer n converted to a string with a base, with a base
+   marker of 0b, 0o or 0x prefixed if applicable.
+
+   If n is not an int object, it is converted with PyNumber_Index first. */
+PyAPI_FUNC(PyObject *) PyNumber_ToBase(PyObject *n, int base);
+
+
+/* === Sequence protocol ================================================ */
+
+/* Return 1 if the object provides sequence protocol, and zero
+   otherwise.
+
+   This function always succeeds. */
+PyAPI_FUNC(int) PySequence_Check(PyObject *o);
+
+/* Return the size of sequence object o, or -1 on failure. */
+PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject *o);
+
+/* For DLL compatibility */
+#undef PySequence_Length
+PyAPI_FUNC(Py_ssize_t) PySequence_Length(PyObject *o);
+#define PySequence_Length PySequence_Size
+
+
+/* Return the concatenation of o1 and o2 on success, and NULL on failure.
+
+   This is the equivalent of the Python expression: o1 + o2. */
+PyAPI_FUNC(PyObject *) PySequence_Concat(PyObject *o1, PyObject *o2);
+
+/* Return the result of repeating sequence object 'o' 'count' times,
+  or NULL on failure.
+
+  This is the equivalent of the Python expression: o * count. */
+PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, Py_ssize_t count);
+
+/* Return the ith element of o, or NULL on failure.
+
+   This is the equivalent of the Python expression: o[i]. */
+PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, Py_ssize_t i);
+
+/* Return the slice of sequence object o between i1 and i2, or NULL on failure.
+
+   This is the equivalent of the Python expression: o[i1:i2]. */
+PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
+
+/* Assign object 'v' to the ith element of the sequence 'o'. Raise an exception
+   and return -1 on failure; return 0 on success.
+
+   This is the equivalent of the Python statement o[i] = v. */
+PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v);
+
+/* Delete the 'i'-th element of the sequence 'v'. Returns -1 on failure.
+
+   This is the equivalent of the Python statement: del o[i]. */
+PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, Py_ssize_t i);
+
+/* Assign the sequence object 'v' to the slice in sequence object 'o',
+   from 'i1' to 'i2'. Returns -1 on failure.
+
+   This is the equivalent of the Python statement: o[i1:i2] = v. */
+PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2,
+                                    PyObject *v);
+
+/* Delete the slice in sequence object 'o' from 'i1' to 'i2'.
+   Returns -1 on failure.
+
+   This is the equivalent of the Python statement: del o[i1:i2]. */
+PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
+
+/* Returns the sequence 'o' as a tuple on success, and NULL on failure.
+
+   This is equivalent to the Python expression: tuple(o). */
+PyAPI_FUNC(PyObject *) PySequence_Tuple(PyObject *o);
+
+/* Returns the sequence 'o' as a list on success, and NULL on failure.
+   This is equivalent to the Python expression: list(o) */
+PyAPI_FUNC(PyObject *) PySequence_List(PyObject *o);
+
+/* Return the sequence 'o' as a list, unless it's already a tuple or list.
+
+   Use PySequence_Fast_GET_ITEM to access the members of this list, and
+   PySequence_Fast_GET_SIZE to get its length.
+
+   Returns NULL on failure.  If the object does not support iteration, raises a
+   TypeError exception with 'm' as the message text. */
+PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m);
+
+/* Return the size of the sequence 'o', assuming that 'o' was returned by
+   PySequence_Fast and is not NULL. */
+#define PySequence_Fast_GET_SIZE(o) \
+    (PyList_Check(o) ? PyList_GET_SIZE(o) : PyTuple_GET_SIZE(o))
+
+/* Return the 'i'-th element of the sequence 'o', assuming that o was returned
+   by PySequence_Fast, and that i is within bounds. */
+#define PySequence_Fast_GET_ITEM(o, i)\
+     (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i))
+
+/* Return a pointer to the underlying item array for
+   an object returned by PySequence_Fast */
+#define PySequence_Fast_ITEMS(sf) \
+    (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \
+                      : ((PyTupleObject *)(sf))->ob_item)
+
+/* Return the number of occurrences on value on 'o', that is, return
+   the number of keys for which o[key] == value.
+
+   On failure, return -1.  This is equivalent to the Python expression:
+   o.count(value). */
+PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject *o, PyObject *value);
+
+/* Return 1 if 'ob' is in the sequence 'seq'; 0 if 'ob' is not in the sequence
+   'seq'; -1 on error.
+
+   Use __contains__ if possible, else _PySequence_IterSearch(). */
+PyAPI_FUNC(int) PySequence_Contains(PyObject *seq, PyObject *ob);
+
+/* For DLL-level backwards compatibility */
+#undef PySequence_In
+/* Determine if the sequence 'o' contains 'value'. If an item in 'o' is equal
+   to 'value', return 1, otherwise return 0. On error, return -1.
+
+   This is equivalent to the Python expression: value in o. */
+PyAPI_FUNC(int) PySequence_In(PyObject *o, PyObject *value);
+
+/* For source-level backwards compatibility */
+#define PySequence_In PySequence_Contains
+
+
+/* Return the first index for which o[i] == value.
+   On error, return -1.
+
+   This is equivalent to the Python expression: o.index(value). */
+PyAPI_FUNC(Py_ssize_t) PySequence_Index(PyObject *o, PyObject *value);
+
+
+/* --- In-place versions of some of the above Sequence functions --- */
+
+/* Append sequence 'o2' to sequence 'o1', in-place when possible. Return the
+   resulting object, which could be 'o1', or NULL on failure.
+
+  This is the equivalent of the Python expression: o1 += o2. */
+PyAPI_FUNC(PyObject *) PySequence_InPlaceConcat(PyObject *o1, PyObject *o2);
+
+/* Repeat sequence 'o' by 'count', in-place when possible. Return the resulting
+   object, which could be 'o', or NULL on failure.
+
+   This is the equivalent of the Python expression: o1 *= count.  */
+PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count);
+
+
+/* === Mapping protocol ================================================= */
+
+/* Return 1 if the object provides mapping protocol, and 0 otherwise.
+
+   This function always succeeds. */
+PyAPI_FUNC(int) PyMapping_Check(PyObject *o);
+
+/* Returns the number of keys in mapping object 'o' on success, and -1 on
+  failure. This is equivalent to the Python expression: len(o). */
+PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject *o);
+
+/* For DLL compatibility */
+#undef PyMapping_Length
+PyAPI_FUNC(Py_ssize_t) PyMapping_Length(PyObject *o);
+#define PyMapping_Length PyMapping_Size
+
+
+/* Implemented as a macro:
+
+   int PyMapping_DelItemString(PyObject *o, const char *key);
+
+   Remove the mapping for the string 'key' from the mapping 'o'. Returns -1 on
+   failure.
+
+   This is equivalent to the Python statement: del o[key]. */
+#define PyMapping_DelItemString(O,K) PyObject_DelItemString((O),(K))
+
+/* Implemented as a macro:
+
+   int PyMapping_DelItem(PyObject *o, PyObject *key);
+
+   Remove the mapping for the object 'key' from the mapping object 'o'.
+   Returns -1 on failure.
+
+   This is equivalent to the Python statement: del o[key]. */
+#define PyMapping_DelItem(O,K) PyObject_DelItem((O),(K))
+
+/* On success, return 1 if the mapping object 'o' has the key 'key',
+   and 0 otherwise.
+
+   This is equivalent to the Python expression: key in o.
+
+   This function always succeeds. */
+PyAPI_FUNC(int) PyMapping_HasKeyString(PyObject *o, const char *key);
+
+/* Return 1 if the mapping object has the key 'key', and 0 otherwise.
+
+   This is equivalent to the Python expression: key in o.
+
+   This function always succeeds. */
+PyAPI_FUNC(int) PyMapping_HasKey(PyObject *o, PyObject *key);
+
+/* On success, return a list or tuple of the keys in mapping object 'o'.
+   On failure, return NULL. */
+PyAPI_FUNC(PyObject *) PyMapping_Keys(PyObject *o);
+
+/* On success, return a list or tuple of the values in mapping object 'o'.
+   On failure, return NULL. */
+PyAPI_FUNC(PyObject *) PyMapping_Values(PyObject *o);
+
+/* On success, return a list or tuple of the items in mapping object 'o',
+   where each item is a tuple containing a key-value pair. On failure, return
+   NULL. */
+PyAPI_FUNC(PyObject *) PyMapping_Items(PyObject *o);
+
+/* Return element of 'o' corresponding to the string 'key' or NULL on failure.
+
+   This is the equivalent of the Python expression: o[key]. */
+PyAPI_FUNC(PyObject *) PyMapping_GetItemString(PyObject *o,
+                                               const char *key);
+
+/* Map the string 'key' to the value 'v' in the mapping 'o'.
+   Returns -1 on failure.
+
+   This is the equivalent of the Python statement: o[key]=v. */
+PyAPI_FUNC(int) PyMapping_SetItemString(PyObject *o, const char *key,
+                                        PyObject *value);
+
+/* isinstance(object, typeorclass) */
+PyAPI_FUNC(int) PyObject_IsInstance(PyObject *object, PyObject *typeorclass);
+
+/* issubclass(object, typeorclass) */
+PyAPI_FUNC(int) PyObject_IsSubclass(PyObject *object, PyObject *typeorclass);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_ABSTRACTOBJECT_H
+#  include  "cpython/abstract.h"
+#  undef Py_CPYTHON_ABSTRACTOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* Py_ABSTRACTOBJECT_H */
diff --git a/marketing/include/asdl.h b/marketing/include/asdl.h
new file mode 100644
index 0000000000000000000000000000000000000000..e962560bcd4cbef2167bfe5e8d4beb9ff87a3911
--- /dev/null
+++ b/marketing/include/asdl.h
@@ -0,0 +1,46 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_ASDL_H
+#define Py_ASDL_H
+
+typedef PyObject * identifier;
+typedef PyObject * string;
+typedef PyObject * object;
+typedef PyObject * constant;
+
+/* It would be nice if the code generated by asdl_c.py was completely
+   independent of Python, but it is a goal the requires too much work
+   at this stage.  So, for example, I'll represent identifiers as
+   interned Python strings.
+*/
+
+/* XXX A sequence should be typed so that its use can be typechecked. */
+
+typedef struct {
+    Py_ssize_t size;
+    void *elements[1];
+} asdl_seq;
+
+typedef struct {
+    Py_ssize_t size;
+    int elements[1];
+} asdl_int_seq;
+
+asdl_seq *_Py_asdl_seq_new(Py_ssize_t size, PyArena *arena);
+asdl_int_seq *_Py_asdl_int_seq_new(Py_ssize_t size, PyArena *arena);
+
+#define asdl_seq_GET(S, I) (S)->elements[(I)]
+#define asdl_seq_LEN(S) ((S) == NULL ? 0 : (S)->size)
+#ifdef Py_DEBUG
+#define asdl_seq_SET(S, I, V) \
+    do { \
+        Py_ssize_t _asdl_i = (I); \
+        assert((S) != NULL); \
+        assert(0 <= _asdl_i && _asdl_i < (S)->size); \
+        (S)->elements[_asdl_i] = (V); \
+    } while (0)
+#else
+#define asdl_seq_SET(S, I, V) (S)->elements[I] = (V)
+#endif
+
+#endif /* !Py_ASDL_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/ast.h b/marketing/include/ast.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8c52af786b1472200b9b3651462f8101f2d8e0a
--- /dev/null
+++ b/marketing/include/ast.h
@@ -0,0 +1,35 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_AST_H
+#define Py_AST_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "Python-ast.h"   /* mod_ty */
+#include "node.h"         /* node */
+
+PyAPI_FUNC(int) PyAST_Validate(mod_ty);
+PyAPI_FUNC(mod_ty) PyAST_FromNode(
+    const node *n,
+    PyCompilerFlags *flags,
+    const char *filename,       /* decoded from the filesystem encoding */
+    PyArena *arena);
+PyAPI_FUNC(mod_ty) PyAST_FromNodeObject(
+    const node *n,
+    PyCompilerFlags *flags,
+    PyObject *filename,
+    PyArena *arena);
+
+/* _PyAST_ExprAsUnicode is defined in ast_unparse.c */
+PyAPI_FUNC(PyObject *) _PyAST_ExprAsUnicode(expr_ty);
+
+/* Return the borrowed reference to the first literal string in the
+   sequence of statements or NULL if it doesn't start from a literal string.
+   Doesn't set exception. */
+PyAPI_FUNC(PyObject *) _PyAST_GetDocString(asdl_seq *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_AST_H */
+#endif /* !Py_LIMITED_API */
diff --git a/marketing/include/bitset.h b/marketing/include/bitset.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a2ac9787eaba30743b053e405c90e09a6308516
--- /dev/null
+++ b/marketing/include/bitset.h
@@ -0,0 +1,23 @@
+
+#ifndef Py_BITSET_H
+#define Py_BITSET_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Bitset interface */
+
+#define BYTE            char
+typedef BYTE *bitset;
+
+#define testbit(ss, ibit) (((ss)[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0)
+
+#define BITSPERBYTE     (8*sizeof(BYTE))
+#define BIT2BYTE(ibit)  ((ibit) / BITSPERBYTE)
+#define BIT2SHIFT(ibit) ((ibit) % BITSPERBYTE)
+#define BIT2MASK(ibit)  (1 << BIT2SHIFT(ibit))
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BITSET_H */
diff --git a/marketing/include/bltinmodule.h b/marketing/include/bltinmodule.h
new file mode 100644
index 0000000000000000000000000000000000000000..868c9e6443bfc1d1d48fb0806af1bf21490fc44c
--- /dev/null
+++ b/marketing/include/bltinmodule.h
@@ -0,0 +1,14 @@
+#ifndef Py_BLTINMODULE_H
+#define Py_BLTINMODULE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyFilter_Type;
+PyAPI_DATA(PyTypeObject) PyMap_Type;
+PyAPI_DATA(PyTypeObject) PyZip_Type;
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BLTINMODULE_H */
diff --git a/marketing/include/boolobject.h b/marketing/include/boolobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb8044a2b02cf6ddb55be24d96ba80e72b7a49bd
--- /dev/null
+++ b/marketing/include/boolobject.h
@@ -0,0 +1,34 @@
+/* Boolean object interface */
+
+#ifndef Py_BOOLOBJECT_H
+#define Py_BOOLOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+PyAPI_DATA(PyTypeObject) PyBool_Type;
+
+#define PyBool_Check(x) Py_IS_TYPE(x, &PyBool_Type)
+
+/* Py_False and Py_True are the only two bools in existence.
+Don't forget to apply Py_INCREF() when returning either!!! */
+
+/* Don't use these directly */
+PyAPI_DATA(struct _longobject) _Py_FalseStruct, _Py_TrueStruct;
+
+/* Use these macros */
+#define Py_False ((PyObject *) &_Py_FalseStruct)
+#define Py_True ((PyObject *) &_Py_TrueStruct)
+
+/* Macros for returning Py_True or Py_False, respectively */
+#define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True
+#define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False
+
+/* Function to return a bool from a C long */
+PyAPI_FUNC(PyObject *) PyBool_FromLong(long);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BOOLOBJECT_H */
diff --git a/marketing/include/bytearrayobject.h b/marketing/include/bytearrayobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e95433f0f26f0b319c1bf5c1c469a0e089a31f2
--- /dev/null
+++ b/marketing/include/bytearrayobject.h
@@ -0,0 +1,46 @@
+/* ByteArray object interface */
+
+#ifndef Py_BYTEARRAYOBJECT_H
+#define Py_BYTEARRAYOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include 
+
+/* Type PyByteArrayObject represents a mutable array of bytes.
+ * The Python API is that of a sequence;
+ * the bytes are mapped to ints in [0, 256).
+ * Bytes are not characters; they may be used to encode characters.
+ * The only way to go between bytes and str/unicode is via encoding
+ * and decoding.
+ * For the convenience of C programmers, the bytes type is considered
+ * to contain a char pointer, not an unsigned char pointer.
+ */
+
+/* Type object */
+PyAPI_DATA(PyTypeObject) PyByteArray_Type;
+PyAPI_DATA(PyTypeObject) PyByteArrayIter_Type;
+
+/* Type check macros */
+#define PyByteArray_Check(self) PyObject_TypeCheck(self, &PyByteArray_Type)
+#define PyByteArray_CheckExact(self) Py_IS_TYPE(self, &PyByteArray_Type)
+
+/* Direct API functions */
+PyAPI_FUNC(PyObject *) PyByteArray_FromObject(PyObject *);
+PyAPI_FUNC(PyObject *) PyByteArray_Concat(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyByteArray_FromStringAndSize(const char *, Py_ssize_t);
+PyAPI_FUNC(Py_ssize_t) PyByteArray_Size(PyObject *);
+PyAPI_FUNC(char *) PyByteArray_AsString(PyObject *);
+PyAPI_FUNC(int) PyByteArray_Resize(PyObject *, Py_ssize_t);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_BYTEARRAYOBJECT_H
+#  include  "cpython/bytearrayobject.h"
+#  undef Py_CPYTHON_BYTEARRAYOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BYTEARRAYOBJECT_H */
diff --git a/marketing/include/bytesobject.h b/marketing/include/bytesobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..5062d8d123ad3e6bdca0311ff821dc3134ea04a2
--- /dev/null
+++ b/marketing/include/bytesobject.h
@@ -0,0 +1,82 @@
+
+/* Bytes (String) object interface */
+
+#ifndef Py_BYTESOBJECT_H
+#define Py_BYTESOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include 
+
+/*
+Type PyBytesObject represents a character string.  An extra zero byte is
+reserved at the end to ensure it is zero-terminated, but a size is
+present so strings with null bytes in them can be represented.  This
+is an immutable object type.
+
+There are functions to create new string objects, to test
+an object for string-ness, and to get the
+string value.  The latter function returns a null pointer
+if the object is not of the proper type.
+There is a variant that takes an explicit size as well as a
+variant that assumes a zero-terminated string.  Note that none of the
+functions should be applied to nil objects.
+*/
+
+/* Caching the hash (ob_shash) saves recalculation of a string's hash value.
+   This significantly speeds up dict lookups. */
+
+PyAPI_DATA(PyTypeObject) PyBytes_Type;
+PyAPI_DATA(PyTypeObject) PyBytesIter_Type;
+
+#define PyBytes_Check(op) \
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_BYTES_SUBCLASS)
+#define PyBytes_CheckExact(op) Py_IS_TYPE(op, &PyBytes_Type)
+
+PyAPI_FUNC(PyObject *) PyBytes_FromStringAndSize(const char *, Py_ssize_t);
+PyAPI_FUNC(PyObject *) PyBytes_FromString(const char *);
+PyAPI_FUNC(PyObject *) PyBytes_FromObject(PyObject *);
+PyAPI_FUNC(PyObject *) PyBytes_FromFormatV(const char*, va_list)
+                                Py_GCC_ATTRIBUTE((format(printf, 1, 0)));
+PyAPI_FUNC(PyObject *) PyBytes_FromFormat(const char*, ...)
+                                Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
+PyAPI_FUNC(Py_ssize_t) PyBytes_Size(PyObject *);
+PyAPI_FUNC(char *) PyBytes_AsString(PyObject *);
+PyAPI_FUNC(PyObject *) PyBytes_Repr(PyObject *, int);
+PyAPI_FUNC(void) PyBytes_Concat(PyObject **, PyObject *);
+PyAPI_FUNC(void) PyBytes_ConcatAndDel(PyObject **, PyObject *);
+PyAPI_FUNC(PyObject *) PyBytes_DecodeEscape(const char *, Py_ssize_t,
+                                            const char *, Py_ssize_t,
+                                            const char *);
+
+/* Provides access to the internal data buffer and size of a string
+   object or the default encoded version of a Unicode object. Passing
+   NULL as *len parameter will force the string buffer to be
+   0-terminated (passing a string with embedded NULL characters will
+   cause an exception).  */
+PyAPI_FUNC(int) PyBytes_AsStringAndSize(
+    PyObject *obj,      /* string or Unicode object */
+    char **s,           /* pointer to buffer variable */
+    Py_ssize_t *len     /* pointer to length variable or NULL
+                           (only possible for 0-terminated
+                           strings) */
+    );
+
+/* Flags used by string formatting */
+#define F_LJUST (1<<0)
+#define F_SIGN  (1<<1)
+#define F_BLANK (1<<2)
+#define F_ALT   (1<<3)
+#define F_ZERO  (1<<4)
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_BYTESOBJECT_H
+#  include  "cpython/bytesobject.h"
+#  undef Py_CPYTHON_BYTESOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BYTESOBJECT_H */
diff --git a/marketing/include/cellobject.h b/marketing/include/cellobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..f12aa90a42a8fe9f4d74b4b235d66a8e112ebeff
--- /dev/null
+++ b/marketing/include/cellobject.h
@@ -0,0 +1,29 @@
+/* Cell object interface */
+#ifndef Py_LIMITED_API
+#ifndef Py_CELLOBJECT_H
+#define Py_CELLOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *ob_ref;       /* Content of the cell or NULL when empty */
+} PyCellObject;
+
+PyAPI_DATA(PyTypeObject) PyCell_Type;
+
+#define PyCell_Check(op) Py_IS_TYPE(op, &PyCell_Type)
+
+PyAPI_FUNC(PyObject *) PyCell_New(PyObject *);
+PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *);
+PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *);
+
+#define PyCell_GET(op) (((PyCellObject *)(op))->ob_ref)
+#define PyCell_SET(op, v) (((PyCellObject *)(op))->ob_ref = v)
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_TUPLEOBJECT_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/ceval.h b/marketing/include/ceval.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f372e2044a1c8ab4ba600331107b4f2dfcd2d14
--- /dev/null
+++ b/marketing/include/ceval.h
@@ -0,0 +1,166 @@
+#ifndef Py_CEVAL_H
+#define Py_CEVAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Interface to random parts in ceval.c */
+
+/* PyEval_CallObjectWithKeywords(), PyEval_CallObject(), PyEval_CallFunction
+ * and PyEval_CallMethod are deprecated. Since they are officially part of the
+ * stable ABI (PEP 384), they must be kept for backward compatibility.
+ * PyObject_Call(), PyObject_CallFunction() and PyObject_CallMethod() are
+ * recommended to call a callable object.
+ */
+
+Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
+    PyObject *callable,
+    PyObject *args,
+    PyObject *kwargs);
+
+/* Deprecated since PyEval_CallObjectWithKeywords is deprecated */
+#define PyEval_CallObject(callable, arg) \
+    PyEval_CallObjectWithKeywords(callable, arg, (PyObject *)NULL)
+
+Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallFunction(
+    PyObject *callable, const char *format, ...);
+Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallMethod(
+    PyObject *obj, const char *name, const char *format, ...);
+
+PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void);
+PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);
+PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);
+PyAPI_FUNC(PyFrameObject *) PyEval_GetFrame(void);
+
+PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg);
+PyAPI_FUNC(int) Py_MakePendingCalls(void);
+
+/* Protection against deeply nested recursive calls
+
+   In Python 3.0, this protection has two levels:
+   * normal anti-recursion protection is triggered when the recursion level
+     exceeds the current recursion limit. It raises a RecursionError, and sets
+     the "overflowed" flag in the thread state structure. This flag
+     temporarily *disables* the normal protection; this allows cleanup code
+     to potentially outgrow the recursion limit while processing the
+     RecursionError.
+   * "last chance" anti-recursion protection is triggered when the recursion
+     level exceeds "current recursion limit + 50". By construction, this
+     protection can only be triggered when the "overflowed" flag is set. It
+     means the cleanup code has itself gone into an infinite loop, or the
+     RecursionError has been mistakingly ignored. When this protection is
+     triggered, the interpreter aborts with a Fatal Error.
+
+   In addition, the "overflowed" flag is automatically reset when the
+   recursion level drops below "current recursion limit - 50". This heuristic
+   is meant to ensure that the normal anti-recursion protection doesn't get
+   disabled too long.
+
+   Please note: this scheme has its own limitations. See:
+   http://mail.python.org/pipermail/python-dev/2008-August/082106.html
+   for some observations.
+*/
+PyAPI_FUNC(void) Py_SetRecursionLimit(int);
+PyAPI_FUNC(int) Py_GetRecursionLimit(void);
+
+PyAPI_FUNC(int) Py_EnterRecursiveCall(const char *where);
+PyAPI_FUNC(void) Py_LeaveRecursiveCall(void);
+
+#define Py_ALLOW_RECURSION \
+  do { unsigned char _old = PyThreadState_GET()->recursion_critical;\
+    PyThreadState_GET()->recursion_critical = 1;
+
+#define Py_END_ALLOW_RECURSION \
+    PyThreadState_GET()->recursion_critical = _old; \
+  } while(0);
+
+PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *);
+PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *);
+
+PyAPI_FUNC(PyObject *) PyEval_EvalFrame(PyFrameObject *);
+PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(PyFrameObject *f, int exc);
+
+/* Interface for threads.
+
+   A module that plans to do a blocking system call (or something else
+   that lasts a long time and doesn't touch Python data) can allow other
+   threads to run as follows:
+
+    ...preparations here...
+    Py_BEGIN_ALLOW_THREADS
+    ...blocking system call here...
+    Py_END_ALLOW_THREADS
+    ...interpret result here...
+
+   The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
+   {}-surrounded block.
+   To leave the block in the middle (e.g., with return), you must insert
+   a line containing Py_BLOCK_THREADS before the return, e.g.
+
+    if (...premature_exit...) {
+        Py_BLOCK_THREADS
+        PyErr_SetFromErrno(PyExc_OSError);
+        return NULL;
+    }
+
+   An alternative is:
+
+    Py_BLOCK_THREADS
+    if (...premature_exit...) {
+        PyErr_SetFromErrno(PyExc_OSError);
+        return NULL;
+    }
+    Py_UNBLOCK_THREADS
+
+   For convenience, that the value of 'errno' is restored across
+   Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.
+
+   WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND
+   Py_END_ALLOW_THREADS!!!
+
+   Note that not yet all candidates have been converted to use this
+   mechanism!
+*/
+
+PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);
+PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);
+
+Py_DEPRECATED(3.9) PyAPI_FUNC(int) PyEval_ThreadsInitialized(void);
+Py_DEPRECATED(3.9) PyAPI_FUNC(void) PyEval_InitThreads(void);
+/* PyEval_AcquireLock() and PyEval_ReleaseLock() are part of stable ABI.
+ * They will be removed from this header file in the future version.
+ * But they will be remained in ABI until Python 4.0.
+ */
+Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_AcquireLock(void);
+Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_ReleaseLock(void);
+PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);
+PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
+
+#define Py_BEGIN_ALLOW_THREADS { \
+                        PyThreadState *_save; \
+                        _save = PyEval_SaveThread();
+#define Py_BLOCK_THREADS        PyEval_RestoreThread(_save);
+#define Py_UNBLOCK_THREADS      _save = PyEval_SaveThread();
+#define Py_END_ALLOW_THREADS    PyEval_RestoreThread(_save); \
+                 }
+
+/* Masks and values used by FORMAT_VALUE opcode. */
+#define FVC_MASK      0x3
+#define FVC_NONE      0x0
+#define FVC_STR       0x1
+#define FVC_REPR      0x2
+#define FVC_ASCII     0x3
+#define FVS_MASK      0x4
+#define FVS_HAVE_SPEC 0x4
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_CEVAL_H
+#  include  "cpython/ceval.h"
+#  undef Py_CPYTHON_CEVAL_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CEVAL_H */
diff --git a/marketing/include/classobject.h b/marketing/include/classobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..1952f673b7d865442a85487f70c36fbab58f7102
--- /dev/null
+++ b/marketing/include/classobject.h
@@ -0,0 +1,57 @@
+/* Former class object interface -- now only bound methods are here  */
+
+/* Revealing some structures (not for general use) */
+
+#ifndef Py_LIMITED_API
+#ifndef Py_CLASSOBJECT_H
+#define Py_CLASSOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *im_func;   /* The callable object implementing the method */
+    PyObject *im_self;   /* The instance it is bound to */
+    PyObject *im_weakreflist; /* List of weak references */
+    vectorcallfunc vectorcall;
+} PyMethodObject;
+
+PyAPI_DATA(PyTypeObject) PyMethod_Type;
+
+#define PyMethod_Check(op) Py_IS_TYPE(op, &PyMethod_Type)
+
+PyAPI_FUNC(PyObject *) PyMethod_New(PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) PyMethod_Function(PyObject *);
+PyAPI_FUNC(PyObject *) PyMethod_Self(PyObject *);
+
+/* Macros for direct access to these values. Type checks are *not*
+   done, so use with care. */
+#define PyMethod_GET_FUNCTION(meth) \
+        (((PyMethodObject *)meth) -> im_func)
+#define PyMethod_GET_SELF(meth) \
+        (((PyMethodObject *)meth) -> im_self)
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *func;
+} PyInstanceMethodObject;
+
+PyAPI_DATA(PyTypeObject) PyInstanceMethod_Type;
+
+#define PyInstanceMethod_Check(op) Py_IS_TYPE(op, &PyInstanceMethod_Type)
+
+PyAPI_FUNC(PyObject *) PyInstanceMethod_New(PyObject *);
+PyAPI_FUNC(PyObject *) PyInstanceMethod_Function(PyObject *);
+
+/* Macros for direct access to these values. Type checks are *not*
+   done, so use with care. */
+#define PyInstanceMethod_GET_FUNCTION(meth) \
+        (((PyInstanceMethodObject *)meth) -> func)
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CLASSOBJECT_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/code.h b/marketing/include/code.h
new file mode 100644
index 0000000000000000000000000000000000000000..b9e23eb816529b52143783c99885565cc3eb58d4
--- /dev/null
+++ b/marketing/include/code.h
@@ -0,0 +1,20 @@
+/* Definitions for bytecode */
+
+#ifndef Py_CODE_H
+#define Py_CODE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PyCodeObject PyCodeObject;
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_CODE_H
+#  include  "cpython/code.h"
+#  undef Py_CPYTHON_CODE_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CODE_H */
diff --git a/marketing/include/codecs.h b/marketing/include/codecs.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ad0f2b5aae79c71c54fabfd51a41aca618f1ac0
--- /dev/null
+++ b/marketing/include/codecs.h
@@ -0,0 +1,240 @@
+#ifndef Py_CODECREGISTRY_H
+#define Py_CODECREGISTRY_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ------------------------------------------------------------------------
+
+   Python Codec Registry and support functions
+
+
+Written by Marc-Andre Lemburg (mal@lemburg.com).
+
+Copyright (c) Corporation for National Research Initiatives.
+
+   ------------------------------------------------------------------------ */
+
+/* Register a new codec search function.
+
+   As side effect, this tries to load the encodings package, if not
+   yet done, to make sure that it is always first in the list of
+   search functions.
+
+   The search_function's refcount is incremented by this function. */
+
+PyAPI_FUNC(int) PyCodec_Register(
+       PyObject *search_function
+       );
+
+/* Codec registry lookup API.
+
+   Looks up the given encoding and returns a CodecInfo object with
+   function attributes which implement the different aspects of
+   processing the encoding.
+
+   The encoding string is looked up converted to all lower-case
+   characters. This makes encodings looked up through this mechanism
+   effectively case-insensitive.
+
+   If no codec is found, a KeyError is set and NULL returned.
+
+   As side effect, this tries to load the encodings package, if not
+   yet done. This is part of the lazy load strategy for the encodings
+   package.
+
+ */
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _PyCodec_Lookup(
+       const char *encoding
+       );
+
+PyAPI_FUNC(int) _PyCodec_Forget(
+       const char *encoding
+       );
+#endif
+
+/* Codec registry encoding check API.
+
+   Returns 1/0 depending on whether there is a registered codec for
+   the given encoding.
+
+*/
+
+PyAPI_FUNC(int) PyCodec_KnownEncoding(
+       const char *encoding
+       );
+
+/* Generic codec based encoding API.
+
+   object is passed through the encoder function found for the given
+   encoding using the error handling method defined by errors. errors
+   may be NULL to use the default method defined for the codec.
+
+   Raises a LookupError in case no encoder can be found.
+
+ */
+
+PyAPI_FUNC(PyObject *) PyCodec_Encode(
+       PyObject *object,
+       const char *encoding,
+       const char *errors
+       );
+
+/* Generic codec based decoding API.
+
+   object is passed through the decoder function found for the given
+   encoding using the error handling method defined by errors. errors
+   may be NULL to use the default method defined for the codec.
+
+   Raises a LookupError in case no encoder can be found.
+
+ */
+
+PyAPI_FUNC(PyObject *) PyCodec_Decode(
+       PyObject *object,
+       const char *encoding,
+       const char *errors
+       );
+
+#ifndef Py_LIMITED_API
+/* Text codec specific encoding and decoding API.
+
+   Checks the encoding against a list of codecs which do not
+   implement a str<->bytes encoding before attempting the
+   operation.
+
+   Please note that these APIs are internal and should not
+   be used in Python C extensions.
+
+   XXX (ncoghlan): should we make these, or something like them, public
+   in Python 3.5+?
+
+ */
+PyAPI_FUNC(PyObject *) _PyCodec_LookupTextEncoding(
+       const char *encoding,
+       const char *alternate_command
+       );
+
+PyAPI_FUNC(PyObject *) _PyCodec_EncodeText(
+       PyObject *object,
+       const char *encoding,
+       const char *errors
+       );
+
+PyAPI_FUNC(PyObject *) _PyCodec_DecodeText(
+       PyObject *object,
+       const char *encoding,
+       const char *errors
+       );
+
+/* These two aren't actually text encoding specific, but _io.TextIOWrapper
+ * is the only current API consumer.
+ */
+PyAPI_FUNC(PyObject *) _PyCodecInfo_GetIncrementalDecoder(
+       PyObject *codec_info,
+       const char *errors
+       );
+
+PyAPI_FUNC(PyObject *) _PyCodecInfo_GetIncrementalEncoder(
+       PyObject *codec_info,
+       const char *errors
+       );
+#endif
+
+
+
+/* --- Codec Lookup APIs --------------------------------------------------
+
+   All APIs return a codec object with incremented refcount and are
+   based on _PyCodec_Lookup().  The same comments w/r to the encoding
+   name also apply to these APIs.
+
+*/
+
+/* Get an encoder function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_Encoder(
+       const char *encoding
+       );
+
+/* Get a decoder function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_Decoder(
+       const char *encoding
+       );
+
+/* Get an IncrementalEncoder object for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_IncrementalEncoder(
+       const char *encoding,
+       const char *errors
+       );
+
+/* Get an IncrementalDecoder object function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_IncrementalDecoder(
+       const char *encoding,
+       const char *errors
+       );
+
+/* Get a StreamReader factory function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_StreamReader(
+       const char *encoding,
+       PyObject *stream,
+       const char *errors
+       );
+
+/* Get a StreamWriter factory function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_StreamWriter(
+       const char *encoding,
+       PyObject *stream,
+       const char *errors
+       );
+
+/* Unicode encoding error handling callback registry API */
+
+/* Register the error handling callback function error under the given
+   name. This function will be called by the codec when it encounters
+   unencodable characters/undecodable bytes and doesn't know the
+   callback name, when name is specified as the error parameter
+   in the call to the encode/decode function.
+   Return 0 on success, -1 on error */
+PyAPI_FUNC(int) PyCodec_RegisterError(const char *name, PyObject *error);
+
+/* Lookup the error handling callback function registered under the given
+   name. As a special case NULL can be passed, in which case
+   the error handling callback for "strict" will be returned. */
+PyAPI_FUNC(PyObject *) PyCodec_LookupError(const char *name);
+
+/* raise exc as an exception */
+PyAPI_FUNC(PyObject *) PyCodec_StrictErrors(PyObject *exc);
+
+/* ignore the unicode error, skipping the faulty input */
+PyAPI_FUNC(PyObject *) PyCodec_IgnoreErrors(PyObject *exc);
+
+/* replace the unicode encode error with ? or U+FFFD */
+PyAPI_FUNC(PyObject *) PyCodec_ReplaceErrors(PyObject *exc);
+
+/* replace the unicode encode error with XML character references */
+PyAPI_FUNC(PyObject *) PyCodec_XMLCharRefReplaceErrors(PyObject *exc);
+
+/* replace the unicode encode error with backslash escapes (\x, \u and \U) */
+PyAPI_FUNC(PyObject *) PyCodec_BackslashReplaceErrors(PyObject *exc);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* replace the unicode encode error with backslash escapes (\N, \x, \u and \U) */
+PyAPI_FUNC(PyObject *) PyCodec_NameReplaceErrors(PyObject *exc);
+#endif
+
+#ifndef Py_LIMITED_API
+PyAPI_DATA(const char *) Py_hexdigits;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CODECREGISTRY_H */
diff --git a/marketing/include/compile.h b/marketing/include/compile.h
new file mode 100644
index 0000000000000000000000000000000000000000..98adee3d19120407ab43e1c3b7f4249c9bcb0cd1
--- /dev/null
+++ b/marketing/include/compile.h
@@ -0,0 +1,116 @@
+#ifndef Py_COMPILE_H
+#define Py_COMPILE_H
+
+#ifndef Py_LIMITED_API
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Public interface */
+struct _node; /* Declare the existence of this type */
+#ifndef Py_BUILD_CORE
+Py_DEPRECATED(3.9)
+#endif
+PyAPI_FUNC(PyCodeObject *) PyNode_Compile(struct _node *, const char *);
+/* XXX (ncoghlan): Unprefixed type name in a public API! */
+
+#define PyCF_MASK (CO_FUTURE_DIVISION | CO_FUTURE_ABSOLUTE_IMPORT | \
+                   CO_FUTURE_WITH_STATEMENT | CO_FUTURE_PRINT_FUNCTION | \
+                   CO_FUTURE_UNICODE_LITERALS | CO_FUTURE_BARRY_AS_BDFL | \
+                   CO_FUTURE_GENERATOR_STOP | CO_FUTURE_ANNOTATIONS)
+#define PyCF_MASK_OBSOLETE (CO_NESTED)
+
+/* bpo-39562: CO_FUTURE_ and PyCF_ constants must be kept unique.
+   PyCF_ constants can use bits from 0x0100 to 0x10000.
+   CO_FUTURE_ constants use bits starting at 0x20000. */
+#define PyCF_SOURCE_IS_UTF8  0x0100
+#define PyCF_DONT_IMPLY_DEDENT 0x0200
+#define PyCF_ONLY_AST 0x0400
+#define PyCF_IGNORE_COOKIE 0x0800
+#define PyCF_TYPE_COMMENTS 0x1000
+#define PyCF_ALLOW_TOP_LEVEL_AWAIT 0x2000
+#define PyCF_COMPILE_MASK (PyCF_ONLY_AST | PyCF_ALLOW_TOP_LEVEL_AWAIT | \
+                           PyCF_TYPE_COMMENTS | PyCF_DONT_IMPLY_DEDENT)
+
+#ifndef Py_LIMITED_API
+typedef struct {
+    int cf_flags;  /* bitmask of CO_xxx flags relevant to future */
+    int cf_feature_version;  /* minor Python version (PyCF_ONLY_AST) */
+} PyCompilerFlags;
+
+#define _PyCompilerFlags_INIT \
+    (PyCompilerFlags){.cf_flags = 0, .cf_feature_version = PY_MINOR_VERSION}
+#endif
+
+/* Future feature support */
+
+typedef struct {
+    int ff_features;      /* flags set by future statements */
+    int ff_lineno;        /* line number of last future statement */
+} PyFutureFeatures;
+
+#define FUTURE_NESTED_SCOPES "nested_scopes"
+#define FUTURE_GENERATORS "generators"
+#define FUTURE_DIVISION "division"
+#define FUTURE_ABSOLUTE_IMPORT "absolute_import"
+#define FUTURE_WITH_STATEMENT "with_statement"
+#define FUTURE_PRINT_FUNCTION "print_function"
+#define FUTURE_UNICODE_LITERALS "unicode_literals"
+#define FUTURE_BARRY_AS_BDFL "barry_as_FLUFL"
+#define FUTURE_GENERATOR_STOP "generator_stop"
+#define FUTURE_ANNOTATIONS "annotations"
+
+struct _mod; /* Declare the existence of this type */
+#define PyAST_Compile(mod, s, f, ar) PyAST_CompileEx(mod, s, f, -1, ar)
+PyAPI_FUNC(PyCodeObject *) PyAST_CompileEx(
+    struct _mod *mod,
+    const char *filename,       /* decoded from the filesystem encoding */
+    PyCompilerFlags *flags,
+    int optimize,
+    PyArena *arena);
+PyAPI_FUNC(PyCodeObject *) PyAST_CompileObject(
+    struct _mod *mod,
+    PyObject *filename,
+    PyCompilerFlags *flags,
+    int optimize,
+    PyArena *arena);
+PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromAST(
+    struct _mod * mod,
+    const char *filename        /* decoded from the filesystem encoding */
+    );
+PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromASTObject(
+    struct _mod * mod,
+    PyObject *filename
+    );
+
+/* _Py_Mangle is defined in compile.c */
+PyAPI_FUNC(PyObject*) _Py_Mangle(PyObject *p, PyObject *name);
+
+#define PY_INVALID_STACK_EFFECT INT_MAX
+PyAPI_FUNC(int) PyCompile_OpcodeStackEffect(int opcode, int oparg);
+PyAPI_FUNC(int) PyCompile_OpcodeStackEffectWithJump(int opcode, int oparg, int jump);
+
+typedef struct {
+    int optimize;
+    int ff_features;
+} _PyASTOptimizeState;
+
+PyAPI_FUNC(int) _PyAST_Optimize(struct _mod *, PyArena *arena, _PyASTOptimizeState *state);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_LIMITED_API */
+
+/* These definitions must match corresponding definitions in graminit.h. */
+#define Py_single_input 256
+#define Py_file_input 257
+#define Py_eval_input 258
+#define Py_func_type_input 345
+
+/* This doesn't need to match anything */
+#define Py_fstring_input 800
+
+#endif /* !Py_COMPILE_H */
diff --git a/marketing/include/complexobject.h b/marketing/include/complexobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..9221f9c51d65be46edcddc81f5c1d1b41a070144
--- /dev/null
+++ b/marketing/include/complexobject.h
@@ -0,0 +1,69 @@
+/* Complex number structure */
+
+#ifndef Py_COMPLEXOBJECT_H
+#define Py_COMPLEXOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+typedef struct {
+    double real;
+    double imag;
+} Py_complex;
+
+/* Operations on complex numbers from complexmodule.c */
+
+PyAPI_FUNC(Py_complex) _Py_c_sum(Py_complex, Py_complex);
+PyAPI_FUNC(Py_complex) _Py_c_diff(Py_complex, Py_complex);
+PyAPI_FUNC(Py_complex) _Py_c_neg(Py_complex);
+PyAPI_FUNC(Py_complex) _Py_c_prod(Py_complex, Py_complex);
+PyAPI_FUNC(Py_complex) _Py_c_quot(Py_complex, Py_complex);
+PyAPI_FUNC(Py_complex) _Py_c_pow(Py_complex, Py_complex);
+PyAPI_FUNC(double) _Py_c_abs(Py_complex);
+#endif
+
+/* Complex object interface */
+
+/*
+PyComplexObject represents a complex number with double-precision
+real and imaginary parts.
+*/
+#ifndef Py_LIMITED_API
+typedef struct {
+    PyObject_HEAD
+    Py_complex cval;
+} PyComplexObject;
+#endif
+
+PyAPI_DATA(PyTypeObject) PyComplex_Type;
+
+#define PyComplex_Check(op) PyObject_TypeCheck(op, &PyComplex_Type)
+#define PyComplex_CheckExact(op) Py_IS_TYPE(op, &PyComplex_Type)
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) PyComplex_FromCComplex(Py_complex);
+#endif
+PyAPI_FUNC(PyObject *) PyComplex_FromDoubles(double real, double imag);
+
+PyAPI_FUNC(double) PyComplex_RealAsDouble(PyObject *op);
+PyAPI_FUNC(double) PyComplex_ImagAsDouble(PyObject *op);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(Py_complex) PyComplex_AsCComplex(PyObject *op);
+#endif
+
+/* Format the object based on the format_spec, as defined in PEP 3101
+   (Advanced String Formatting). */
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(int) _PyComplex_FormatAdvancedWriter(
+    _PyUnicodeWriter *writer,
+    PyObject *obj,
+    PyObject *format_spec,
+    Py_ssize_t start,
+    Py_ssize_t end);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_COMPLEXOBJECT_H */
diff --git a/marketing/include/context.h b/marketing/include/context.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e5007089dd94bc1a50ca07340674deace6188bf
--- /dev/null
+++ b/marketing/include/context.h
@@ -0,0 +1,81 @@
+#ifndef Py_CONTEXT_H
+#define Py_CONTEXT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+
+
+PyAPI_DATA(PyTypeObject) PyContext_Type;
+typedef struct _pycontextobject PyContext;
+
+PyAPI_DATA(PyTypeObject) PyContextVar_Type;
+typedef struct _pycontextvarobject PyContextVar;
+
+PyAPI_DATA(PyTypeObject) PyContextToken_Type;
+typedef struct _pycontexttokenobject PyContextToken;
+
+
+#define PyContext_CheckExact(o) Py_IS_TYPE(o, &PyContext_Type)
+#define PyContextVar_CheckExact(o) Py_IS_TYPE(o, &PyContextVar_Type)
+#define PyContextToken_CheckExact(o) Py_IS_TYPE(o, &PyContextToken_Type)
+
+
+PyAPI_FUNC(PyObject *) PyContext_New(void);
+PyAPI_FUNC(PyObject *) PyContext_Copy(PyObject *);
+PyAPI_FUNC(PyObject *) PyContext_CopyCurrent(void);
+
+PyAPI_FUNC(int) PyContext_Enter(PyObject *);
+PyAPI_FUNC(int) PyContext_Exit(PyObject *);
+
+
+/* Create a new context variable.
+
+   default_value can be NULL.
+*/
+PyAPI_FUNC(PyObject *) PyContextVar_New(
+    const char *name, PyObject *default_value);
+
+
+/* Get a value for the variable.
+
+   Returns -1 if an error occurred during lookup.
+
+   Returns 0 if value either was or was not found.
+
+   If value was found, *value will point to it.
+   If not, it will point to:
+
+   - default_value, if not NULL;
+   - the default value of "var", if not NULL;
+   - NULL.
+
+   '*value' will be a new ref, if not NULL.
+*/
+PyAPI_FUNC(int) PyContextVar_Get(
+    PyObject *var, PyObject *default_value, PyObject **value);
+
+
+/* Set a new value for the variable.
+   Returns NULL if an error occurs.
+*/
+PyAPI_FUNC(PyObject *) PyContextVar_Set(PyObject *var, PyObject *value);
+
+
+/* Reset a variable to its previous value.
+   Returns 0 on success, -1 on error.
+*/
+PyAPI_FUNC(int) PyContextVar_Reset(PyObject *var, PyObject *token);
+
+
+/* This method is exposed only for CPython tests. Don not use it. */
+PyAPI_FUNC(PyObject *) _PyContext_NewHamtForTests(void);
+
+
+#endif /* !Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CONTEXT_H */
diff --git a/marketing/include/cpython/abstract.h b/marketing/include/cpython/abstract.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f1304d26af335881960445544bd8491f9d810e1
--- /dev/null
+++ b/marketing/include/cpython/abstract.h
@@ -0,0 +1,384 @@
+#ifndef Py_CPYTHON_ABSTRACTOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* === Object Protocol ================================================== */
+
+#ifdef PY_SSIZE_T_CLEAN
+#  define _PyObject_CallMethodId _PyObject_CallMethodId_SizeT
+#endif
+
+/* Convert keyword arguments from the FASTCALL (stack: C array, kwnames: tuple)
+   format to a Python dictionary ("kwargs" dict).
+
+   The type of kwnames keys is not checked. The final function getting
+   arguments is responsible to check if all keys are strings, for example using
+   PyArg_ParseTupleAndKeywords() or PyArg_ValidateKeywordArguments().
+
+   Duplicate keys are merged using the last value. If duplicate keys must raise
+   an exception, the caller is responsible to implement an explicit keys on
+   kwnames. */
+PyAPI_FUNC(PyObject *) _PyStack_AsDict(
+    PyObject *const *values,
+    PyObject *kwnames);
+
+/* Suggested size (number of positional arguments) for arrays of PyObject*
+   allocated on a C stack to avoid allocating memory on the heap memory. Such
+   array is used to pass positional arguments to call functions of the
+   PyObject_Vectorcall() family.
+
+   The size is chosen to not abuse the C stack and so limit the risk of stack
+   overflow. The size is also chosen to allow using the small stack for most
+   function calls of the Python standard library. On 64-bit CPU, it allocates
+   40 bytes on the stack. */
+#define _PY_FASTCALL_SMALL_STACK 5
+
+PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult(
+    PyThreadState *tstate,
+    PyObject *callable,
+    PyObject *result,
+    const char *where);
+
+/* === Vectorcall protocol (PEP 590) ============================= */
+
+/* Call callable using tp_call. Arguments are like PyObject_Vectorcall()
+   or PyObject_FastCallDict() (both forms are supported),
+   except that nargs is plainly the number of arguments without flags. */
+PyAPI_FUNC(PyObject *) _PyObject_MakeTpCall(
+    PyThreadState *tstate,
+    PyObject *callable,
+    PyObject *const *args, Py_ssize_t nargs,
+    PyObject *keywords);
+
+#define PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1))
+
+static inline Py_ssize_t
+PyVectorcall_NARGS(size_t n)
+{
+    return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET;
+}
+
+static inline vectorcallfunc
+PyVectorcall_Function(PyObject *callable)
+{
+    PyTypeObject *tp;
+    Py_ssize_t offset;
+    vectorcallfunc ptr;
+
+    assert(callable != NULL);
+    tp = Py_TYPE(callable);
+    if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) {
+        return NULL;
+    }
+    assert(PyCallable_Check(callable));
+    offset = tp->tp_vectorcall_offset;
+    assert(offset > 0);
+    memcpy(&ptr, (char *) callable + offset, sizeof(ptr));
+    return ptr;
+}
+
+/* Call the callable object 'callable' with the "vectorcall" calling
+   convention.
+
+   args is a C array for positional arguments.
+
+   nargsf is the number of positional arguments plus optionally the flag
+   PY_VECTORCALL_ARGUMENTS_OFFSET which means that the caller is allowed to
+   modify args[-1].
+
+   kwnames is a tuple of keyword names. The values of the keyword arguments
+   are stored in "args" after the positional arguments (note that the number
+   of keyword arguments does not change nargsf). kwnames can also be NULL if
+   there are no keyword arguments.
+
+   keywords must only contain strings and all keys must be unique.
+
+   Return the result on success. Raise an exception and return NULL on
+   error. */
+static inline PyObject *
+_PyObject_VectorcallTstate(PyThreadState *tstate, PyObject *callable,
+                           PyObject *const *args, size_t nargsf,
+                           PyObject *kwnames)
+{
+    vectorcallfunc func;
+    PyObject *res;
+
+    assert(kwnames == NULL || PyTuple_Check(kwnames));
+    assert(args != NULL || PyVectorcall_NARGS(nargsf) == 0);
+
+    func = PyVectorcall_Function(callable);
+    if (func == NULL) {
+        Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+        return _PyObject_MakeTpCall(tstate, callable, args, nargs, kwnames);
+    }
+    res = func(callable, args, nargsf, kwnames);
+    return _Py_CheckFunctionResult(tstate, callable, res, NULL);
+}
+
+static inline PyObject *
+PyObject_Vectorcall(PyObject *callable, PyObject *const *args,
+                     size_t nargsf, PyObject *kwnames)
+{
+    PyThreadState *tstate = PyThreadState_GET();
+    return _PyObject_VectorcallTstate(tstate, callable,
+                                      args, nargsf, kwnames);
+}
+
+// Backwards compatibility aliases for API that was provisional in Python 3.8
+#define _PyObject_Vectorcall PyObject_Vectorcall
+#define _PyObject_VectorcallMethod PyObject_VectorcallMethod
+#define _PyObject_FastCallDict PyObject_VectorcallDict
+#define _PyVectorcall_Function PyVectorcall_Function
+#define _PyObject_CallOneArg PyObject_CallOneArg
+#define _PyObject_CallMethodNoArgs PyObject_CallMethodNoArgs
+#define _PyObject_CallMethodOneArg PyObject_CallMethodOneArg
+
+/* Same as PyObject_Vectorcall except that keyword arguments are passed as
+   dict, which may be NULL if there are no keyword arguments. */
+PyAPI_FUNC(PyObject *) PyObject_VectorcallDict(
+    PyObject *callable,
+    PyObject *const *args,
+    size_t nargsf,
+    PyObject *kwargs);
+
+/* Call "callable" (which must support vectorcall) with positional arguments
+   "tuple" and keyword arguments "dict". "dict" may also be NULL */
+PyAPI_FUNC(PyObject *) PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *dict);
+
+static inline PyObject *
+_PyObject_FastCallTstate(PyThreadState *tstate, PyObject *func, PyObject *const *args, Py_ssize_t nargs)
+{
+    return _PyObject_VectorcallTstate(tstate, func, args, (size_t)nargs, NULL);
+}
+
+/* Same as PyObject_Vectorcall except without keyword arguments */
+static inline PyObject *
+_PyObject_FastCall(PyObject *func, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyThreadState *tstate = PyThreadState_GET();
+    return _PyObject_FastCallTstate(tstate, func, args, nargs);
+}
+
+/* Call a callable without any arguments
+   Private static inline function variant of public function
+   PyObject_CallNoArgs(). */
+static inline PyObject *
+_PyObject_CallNoArg(PyObject *func) {
+    PyThreadState *tstate = PyThreadState_GET();
+    return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL);
+}
+
+static inline PyObject *
+PyObject_CallOneArg(PyObject *func, PyObject *arg)
+{
+    PyObject *_args[2];
+    PyObject **args;
+    PyThreadState *tstate;
+    size_t nargsf;
+
+    assert(arg != NULL);
+    args = _args + 1;  // For PY_VECTORCALL_ARGUMENTS_OFFSET
+    args[0] = arg;
+    tstate = PyThreadState_GET();
+    nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;
+    return _PyObject_VectorcallTstate(tstate, func, args, nargsf, NULL);
+}
+
+PyAPI_FUNC(PyObject *) PyObject_VectorcallMethod(
+    PyObject *name, PyObject *const *args,
+    size_t nargsf, PyObject *kwnames);
+
+static inline PyObject *
+PyObject_CallMethodNoArgs(PyObject *self, PyObject *name)
+{
+    return PyObject_VectorcallMethod(name, &self,
+           1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+}
+
+static inline PyObject *
+PyObject_CallMethodOneArg(PyObject *self, PyObject *name, PyObject *arg)
+{
+    PyObject *args[2] = {self, arg};
+
+    assert(arg != NULL);
+    return PyObject_VectorcallMethod(name, args,
+           2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+}
+
+/* Like PyObject_CallMethod(), but expect a _Py_Identifier*
+   as the method name. */
+PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj,
+                                              _Py_Identifier *name,
+                                              const char *format, ...);
+
+PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj,
+                                                    _Py_Identifier *name,
+                                                    const char *format,
+                                                    ...);
+
+PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs(
+    PyObject *obj,
+    struct _Py_Identifier *name,
+    ...);
+
+static inline PyObject *
+_PyObject_VectorcallMethodId(
+    _Py_Identifier *name, PyObject *const *args,
+    size_t nargsf, PyObject *kwnames)
+{
+    PyObject *oname = _PyUnicode_FromId(name); /* borrowed */
+    if (!oname) {
+        return NULL;
+    }
+    return PyObject_VectorcallMethod(oname, args, nargsf, kwnames);
+}
+
+static inline PyObject *
+_PyObject_CallMethodIdNoArgs(PyObject *self, _Py_Identifier *name)
+{
+    return _PyObject_VectorcallMethodId(name, &self,
+           1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+}
+
+static inline PyObject *
+_PyObject_CallMethodIdOneArg(PyObject *self, _Py_Identifier *name, PyObject *arg)
+{
+    PyObject *args[2] = {self, arg};
+
+    assert(arg != NULL);
+    return _PyObject_VectorcallMethodId(name, args,
+           2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+}
+
+PyAPI_FUNC(int) _PyObject_HasLen(PyObject *o);
+
+/* Guess the size of object 'o' using len(o) or o.__length_hint__().
+   If neither of those return a non-negative value, then return the default
+   value.  If one of the calls fails, this function returns -1. */
+PyAPI_FUNC(Py_ssize_t) PyObject_LengthHint(PyObject *o, Py_ssize_t);
+
+/* === New Buffer API ============================================ */
+
+/* Return 1 if the getbuffer function is available, otherwise return 0. */
+PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject *obj);
+
+/* This is a C-API version of the getbuffer function call.  It checks
+   to make sure object has the required function pointer and issues the
+   call.
+
+   Returns -1 and raises an error on failure and returns 0 on success. */
+PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
+                                   int flags);
+
+/* Get the memory area pointed to by the indices for the buffer given.
+   Note that view->ndim is the assumed size of indices. */
+PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);
+
+/* Return the implied itemsize of the data-format area from a
+   struct-style description. */
+PyAPI_FUNC(Py_ssize_t) PyBuffer_SizeFromFormat(const char *format);
+
+/* Implementation in memoryobject.c */
+PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view,
+                                      Py_ssize_t len, char order);
+
+PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf,
+                                        Py_ssize_t len, char order);
+
+/* Copy len bytes of data from the contiguous chunk of memory
+   pointed to by buf into the buffer exported by obj.  Return
+   0 on success and return -1 and raise a PyBuffer_Error on
+   error (i.e. the object does not have a buffer interface or
+   it is not working).
+
+   If fort is 'F', then if the object is multi-dimensional,
+   then the data will be copied into the array in
+   Fortran-style (first dimension varies the fastest).  If
+   fort is 'C', then the data will be copied into the array
+   in C-style (last dimension varies the fastest).  If fort
+   is 'A', then it does not matter and the copy will be made
+   in whatever way is more efficient. */
+PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src);
+
+/* Copy the data from the src buffer to the buffer of destination. */
+PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort);
+
+/*Fill the strides array with byte-strides of a contiguous
+  (Fortran-style if fort is 'F' or C-style otherwise)
+  array of the given shape with the given number of bytes
+  per element. */
+PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims,
+                                               Py_ssize_t *shape,
+                                               Py_ssize_t *strides,
+                                               int itemsize,
+                                               char fort);
+
+/* Fills in a buffer-info structure correctly for an exporter
+   that can only share a contiguous chunk of memory of
+   "unsigned bytes" of the given length.
+
+   Returns 0 on success and -1 (with raising an error) on error. */
+PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf,
+                                  Py_ssize_t len, int readonly,
+                                  int flags);
+
+/* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */
+PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view);
+
+/* ==== Iterators ================================================ */
+
+#define PyIter_Check(obj) \
+    (Py_TYPE(obj)->tp_iternext != NULL && \
+     Py_TYPE(obj)->tp_iternext != &_PyObject_NextNotImplemented)
+
+/* === Sequence protocol ================================================ */
+
+/* Assume tp_as_sequence and sq_item exist and that 'i' does not
+   need to be corrected for a negative index. */
+#define PySequence_ITEM(o, i)\
+    ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) )
+
+#define PY_ITERSEARCH_COUNT    1
+#define PY_ITERSEARCH_INDEX    2
+#define PY_ITERSEARCH_CONTAINS 3
+
+/* Iterate over seq.
+
+   Result depends on the operation:
+
+   PY_ITERSEARCH_COUNT:  return # of times obj appears in seq; -1 if
+     error.
+   PY_ITERSEARCH_INDEX:  return 0-based index of first occurrence of
+     obj in seq; set ValueError and return -1 if none found;
+     also return -1 on error.
+   PY_ITERSEARCH_CONTAINS:  return 1 if obj in seq, else 0; -1 on
+     error. */
+PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq,
+                                              PyObject *obj, int operation);
+
+/* === Mapping protocol ================================================= */
+
+PyAPI_FUNC(int) _PyObject_RealIsInstance(PyObject *inst, PyObject *cls);
+
+PyAPI_FUNC(int) _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls);
+
+PyAPI_FUNC(char *const *) _PySequence_BytesToCharpArray(PyObject* self);
+
+PyAPI_FUNC(void) _Py_FreeCharPArray(char *const array[]);
+
+/* For internal use by buffer API functions */
+PyAPI_FUNC(void) _Py_add_one_to_index_F(int nd, Py_ssize_t *index,
+                                        const Py_ssize_t *shape);
+PyAPI_FUNC(void) _Py_add_one_to_index_C(int nd, Py_ssize_t *index,
+                                        const Py_ssize_t *shape);
+
+/* Convert Python int to Py_ssize_t. Do nothing if the argument is None. */
+PyAPI_FUNC(int) _Py_convert_optional_to_ssize_t(PyObject *, void *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/bytearrayobject.h b/marketing/include/cpython/bytearrayobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..569b0cd0369861a4bbc539d676599ea4329859e1
--- /dev/null
+++ b/marketing/include/cpython/bytearrayobject.h
@@ -0,0 +1,20 @@
+#ifndef Py_CPYTHON_BYTEARRAYOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+/* Object layout */
+typedef struct {
+    PyObject_VAR_HEAD
+    Py_ssize_t ob_alloc;   /* How many bytes allocated in ob_bytes */
+    char *ob_bytes;        /* Physical backing buffer */
+    char *ob_start;        /* Logical start inside ob_bytes */
+    Py_ssize_t ob_exports; /* How many buffer exports */
+} PyByteArrayObject;
+
+/* Macros, trading safety for speed */
+#define PyByteArray_AS_STRING(self) \
+    (assert(PyByteArray_Check(self)), \
+     Py_SIZE(self) ? ((PyByteArrayObject *)(self))->ob_start : _PyByteArray_empty_string)
+#define PyByteArray_GET_SIZE(self) (assert(PyByteArray_Check(self)), Py_SIZE(self))
+
+PyAPI_DATA(char) _PyByteArray_empty_string[];
diff --git a/marketing/include/cpython/bytesobject.h b/marketing/include/cpython/bytesobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..f284c5835df099a01ec646bb78c35ef66212a1b6
--- /dev/null
+++ b/marketing/include/cpython/bytesobject.h
@@ -0,0 +1,118 @@
+#ifndef Py_CPYTHON_BYTESOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+typedef struct {
+    PyObject_VAR_HEAD
+    Py_hash_t ob_shash;
+    char ob_sval[1];
+
+    /* Invariants:
+     *     ob_sval contains space for 'ob_size+1' elements.
+     *     ob_sval[ob_size] == 0.
+     *     ob_shash is the hash of the string or -1 if not computed yet.
+     */
+} PyBytesObject;
+
+PyAPI_FUNC(int) _PyBytes_Resize(PyObject **, Py_ssize_t);
+PyAPI_FUNC(PyObject*) _PyBytes_FormatEx(
+    const char *format,
+    Py_ssize_t format_len,
+    PyObject *args,
+    int use_bytearray);
+PyAPI_FUNC(PyObject*) _PyBytes_FromHex(
+    PyObject *string,
+    int use_bytearray);
+
+/* Helper for PyBytes_DecodeEscape that detects invalid escape chars. */
+PyAPI_FUNC(PyObject *) _PyBytes_DecodeEscape(const char *, Py_ssize_t,
+                                             const char *, const char **);
+
+/* Macro, trading safety for speed */
+#define PyBytes_AS_STRING(op) (assert(PyBytes_Check(op)), \
+                                (((PyBytesObject *)(op))->ob_sval))
+#define PyBytes_GET_SIZE(op)  (assert(PyBytes_Check(op)),Py_SIZE(op))
+
+/* _PyBytes_Join(sep, x) is like sep.join(x).  sep must be PyBytesObject*,
+   x must be an iterable object. */
+PyAPI_FUNC(PyObject *) _PyBytes_Join(PyObject *sep, PyObject *x);
+
+
+/* The _PyBytesWriter structure is big: it contains an embedded "stack buffer".
+   A _PyBytesWriter variable must be declared at the end of variables in a
+   function to optimize the memory allocation on the stack. */
+typedef struct {
+    /* bytes, bytearray or NULL (when the small buffer is used) */
+    PyObject *buffer;
+
+    /* Number of allocated size. */
+    Py_ssize_t allocated;
+
+    /* Minimum number of allocated bytes,
+       incremented by _PyBytesWriter_Prepare() */
+    Py_ssize_t min_size;
+
+    /* If non-zero, use a bytearray instead of a bytes object for buffer. */
+    int use_bytearray;
+
+    /* If non-zero, overallocate the buffer (default: 0).
+       This flag must be zero if use_bytearray is non-zero. */
+    int overallocate;
+
+    /* Stack buffer */
+    int use_small_buffer;
+    char small_buffer[512];
+} _PyBytesWriter;
+
+/* Initialize a bytes writer
+
+   By default, the overallocation is disabled. Set the overallocate attribute
+   to control the allocation of the buffer. */
+PyAPI_FUNC(void) _PyBytesWriter_Init(_PyBytesWriter *writer);
+
+/* Get the buffer content and reset the writer.
+   Return a bytes object, or a bytearray object if use_bytearray is non-zero.
+   Raise an exception and return NULL on error. */
+PyAPI_FUNC(PyObject *) _PyBytesWriter_Finish(_PyBytesWriter *writer,
+    void *str);
+
+/* Deallocate memory of a writer (clear its internal buffer). */
+PyAPI_FUNC(void) _PyBytesWriter_Dealloc(_PyBytesWriter *writer);
+
+/* Allocate the buffer to write size bytes.
+   Return the pointer to the beginning of buffer data.
+   Raise an exception and return NULL on error. */
+PyAPI_FUNC(void*) _PyBytesWriter_Alloc(_PyBytesWriter *writer,
+    Py_ssize_t size);
+
+/* Ensure that the buffer is large enough to write *size* bytes.
+   Add size to the writer minimum size (min_size attribute).
+
+   str is the current pointer inside the buffer.
+   Return the updated current pointer inside the buffer.
+   Raise an exception and return NULL on error. */
+PyAPI_FUNC(void*) _PyBytesWriter_Prepare(_PyBytesWriter *writer,
+    void *str,
+    Py_ssize_t size);
+
+/* Resize the buffer to make it larger.
+   The new buffer may be larger than size bytes because of overallocation.
+   Return the updated current pointer inside the buffer.
+   Raise an exception and return NULL on error.
+
+   Note: size must be greater than the number of allocated bytes in the writer.
+
+   This function doesn't use the writer minimum size (min_size attribute).
+
+   See also _PyBytesWriter_Prepare().
+   */
+PyAPI_FUNC(void*) _PyBytesWriter_Resize(_PyBytesWriter *writer,
+    void *str,
+    Py_ssize_t size);
+
+/* Write bytes.
+   Raise an exception and return NULL on error. */
+PyAPI_FUNC(void*) _PyBytesWriter_WriteBytes(_PyBytesWriter *writer,
+    void *str,
+    const void *bytes,
+    Py_ssize_t size);
diff --git a/marketing/include/cpython/ceval.h b/marketing/include/cpython/ceval.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1922a677bd38c0563cc491c4e2969fdd872f812
--- /dev/null
+++ b/marketing/include/cpython/ceval.h
@@ -0,0 +1,38 @@
+#ifndef Py_CPYTHON_CEVAL_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *);
+PyAPI_DATA(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg);
+PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *);
+PyAPI_FUNC(int) _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg);
+PyAPI_FUNC(int) _PyEval_GetCoroutineOriginTrackingDepth(void);
+PyAPI_FUNC(int) _PyEval_SetAsyncGenFirstiter(PyObject *);
+PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFirstiter(void);
+PyAPI_FUNC(int) _PyEval_SetAsyncGenFinalizer(PyObject *);
+PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFinalizer(void);
+
+/* Helper to look up a builtin object */
+PyAPI_FUNC(PyObject *) _PyEval_GetBuiltinId(_Py_Identifier *);
+/* Look at the current frame's (if any) code's co_flags, and turn on
+   the corresponding compiler flags in cf->cf_flags.  Return 1 if any
+   flag was set, else return 0. */
+PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
+
+PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int exc);
+
+PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds);
+PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void);
+
+PyAPI_FUNC(Py_ssize_t) _PyEval_RequestCodeExtraIndex(freefunc);
+
+PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/code.h b/marketing/include/cpython/code.h
new file mode 100644
index 0000000000000000000000000000000000000000..cda28ac6ee9343d5c08c07699688ac4f2fe1ffb3
--- /dev/null
+++ b/marketing/include/cpython/code.h
@@ -0,0 +1,165 @@
+#ifndef Py_CPYTHON_CODE_H
+#  error "this header file must not be included directly"
+#endif
+
+typedef uint16_t _Py_CODEUNIT;
+
+#ifdef WORDS_BIGENDIAN
+#  define _Py_OPCODE(word) ((word) >> 8)
+#  define _Py_OPARG(word) ((word) & 255)
+#else
+#  define _Py_OPCODE(word) ((word) & 255)
+#  define _Py_OPARG(word) ((word) >> 8)
+#endif
+
+typedef struct _PyOpcache _PyOpcache;
+
+/* Bytecode object */
+struct PyCodeObject {
+    PyObject_HEAD
+    int co_argcount;            /* #arguments, except *args */
+    int co_posonlyargcount;     /* #positional only arguments */
+    int co_kwonlyargcount;      /* #keyword only arguments */
+    int co_nlocals;             /* #local variables */
+    int co_stacksize;           /* #entries needed for evaluation stack */
+    int co_flags;               /* CO_..., see below */
+    int co_firstlineno;         /* first source line number */
+    PyObject *co_code;          /* instruction opcodes */
+    PyObject *co_consts;        /* list (constants used) */
+    PyObject *co_names;         /* list of strings (names used) */
+    PyObject *co_varnames;      /* tuple of strings (local variable names) */
+    PyObject *co_freevars;      /* tuple of strings (free variable names) */
+    PyObject *co_cellvars;      /* tuple of strings (cell variable names) */
+    /* The rest aren't used in either hash or comparisons, except for co_name,
+       used in both. This is done to preserve the name and line number
+       for tracebacks and debuggers; otherwise, constant de-duplication
+       would collapse identical functions/lambdas defined on different lines.
+    */
+    Py_ssize_t *co_cell2arg;    /* Maps cell vars which are arguments. */
+    PyObject *co_filename;      /* unicode (where it was loaded from) */
+    PyObject *co_name;          /* unicode (name, for reference) */
+    PyObject *co_lnotab;        /* string (encoding addr<->lineno mapping) See
+                                   Objects/lnotab_notes.txt for details. */
+    void *co_zombieframe;       /* for optimization only (see frameobject.c) */
+    PyObject *co_weakreflist;   /* to support weakrefs to code objects */
+    /* Scratch space for extra data relating to the code object.
+       Type is a void* to keep the format private in codeobject.c to force
+       people to go through the proper APIs. */
+    void *co_extra;
+
+    /* Per opcodes just-in-time cache
+     *
+     * To reduce cache size, we use indirect mapping from opcode index to
+     * cache object:
+     *   cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
+     */
+
+    // co_opcache_map is indexed by (next_instr - first_instr).
+    //  * 0 means there is no cache for this opcode.
+    //  * n > 0 means there is cache in co_opcache[n-1].
+    unsigned char *co_opcache_map;
+    _PyOpcache *co_opcache;
+    int co_opcache_flag;  // used to determine when create a cache.
+    unsigned char co_opcache_size;  // length of co_opcache.
+};
+
+/* Masks for co_flags above */
+#define CO_OPTIMIZED    0x0001
+#define CO_NEWLOCALS    0x0002
+#define CO_VARARGS      0x0004
+#define CO_VARKEYWORDS  0x0008
+#define CO_NESTED       0x0010
+#define CO_GENERATOR    0x0020
+/* The CO_NOFREE flag is set if there are no free or cell variables.
+   This information is redundant, but it allows a single flag test
+   to determine whether there is any extra work to be done when the
+   call frame it setup.
+*/
+#define CO_NOFREE       0x0040
+
+/* The CO_COROUTINE flag is set for coroutine functions (defined with
+   ``async def`` keywords) */
+#define CO_COROUTINE            0x0080
+#define CO_ITERABLE_COROUTINE   0x0100
+#define CO_ASYNC_GENERATOR      0x0200
+
+/* bpo-39562: These constant values are changed in Python 3.9
+   to prevent collision with compiler flags. CO_FUTURE_ and PyCF_
+   constants must be kept unique. PyCF_ constants can use bits from
+   0x0100 to 0x10000. CO_FUTURE_ constants use bits starting at 0x20000. */
+#define CO_FUTURE_DIVISION      0x20000
+#define CO_FUTURE_ABSOLUTE_IMPORT 0x40000 /* do absolute imports by default */
+#define CO_FUTURE_WITH_STATEMENT  0x80000
+#define CO_FUTURE_PRINT_FUNCTION  0x100000
+#define CO_FUTURE_UNICODE_LITERALS 0x200000
+
+#define CO_FUTURE_BARRY_AS_BDFL  0x400000
+#define CO_FUTURE_GENERATOR_STOP  0x800000
+#define CO_FUTURE_ANNOTATIONS    0x1000000
+
+/* This value is found in the co_cell2arg array when the associated cell
+   variable does not correspond to an argument. */
+#define CO_CELL_NOT_AN_ARG (-1)
+
+/* This should be defined if a future statement modifies the syntax.
+   For example, when a keyword is added.
+*/
+#define PY_PARSER_REQUIRES_FUTURE_KEYWORD
+
+#define CO_MAXBLOCKS 20 /* Max static block nesting within a function */
+
+PyAPI_DATA(PyTypeObject) PyCode_Type;
+
+#define PyCode_Check(op) Py_IS_TYPE(op, &PyCode_Type)
+#define PyCode_GetNumFree(op) (PyTuple_GET_SIZE((op)->co_freevars))
+
+/* Public interface */
+PyAPI_FUNC(PyCodeObject *) PyCode_New(
+        int, int, int, int, int, PyObject *, PyObject *,
+        PyObject *, PyObject *, PyObject *, PyObject *,
+        PyObject *, PyObject *, int, PyObject *);
+
+PyAPI_FUNC(PyCodeObject *) PyCode_NewWithPosOnlyArgs(
+        int, int, int, int, int, int, PyObject *, PyObject *,
+        PyObject *, PyObject *, PyObject *, PyObject *,
+        PyObject *, PyObject *, int, PyObject *);
+        /* same as struct above */
+
+/* Creates a new empty code object with the specified source location. */
+PyAPI_FUNC(PyCodeObject *)
+PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno);
+
+/* Return the line number associated with the specified bytecode index
+   in this code object.  If you just need the line number of a frame,
+   use PyFrame_GetLineNumber() instead. */
+PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int);
+
+/* for internal use only */
+typedef struct _addr_pair {
+        int ap_lower;
+        int ap_upper;
+} PyAddrPair;
+
+/* Update *bounds to describe the first and one-past-the-last instructions in the
+   same line as lasti.  Return the number of that line.
+*/
+PyAPI_FUNC(int) _PyCode_CheckLineNumber(PyCodeObject* co,
+                                        int lasti, PyAddrPair *bounds);
+
+/* Create a comparable key used to compare constants taking in account the
+ * object type. It is used to make sure types are not coerced (e.g., float and
+ * complex) _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms
+ *
+ * Return (type(obj), obj, ...): a tuple with variable size (at least 2 items)
+ * depending on the type and the value. The type is the first item to not
+ * compare bytes and str which can raise a BytesWarning exception. */
+PyAPI_FUNC(PyObject*) _PyCode_ConstantKey(PyObject *obj);
+
+PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts,
+                                      PyObject *names, PyObject *lnotab);
+
+
+PyAPI_FUNC(int) _PyCode_GetExtra(PyObject *code, Py_ssize_t index,
+                                 void **extra);
+PyAPI_FUNC(int) _PyCode_SetExtra(PyObject *code, Py_ssize_t index,
+                                 void *extra);
diff --git a/marketing/include/cpython/dictobject.h b/marketing/include/cpython/dictobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..50f4c4a9e5502b2d5cb12c7905e8dde8b17350e6
--- /dev/null
+++ b/marketing/include/cpython/dictobject.h
@@ -0,0 +1,92 @@
+#ifndef Py_CPYTHON_DICTOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _dictkeysobject PyDictKeysObject;
+
+/* The ma_values pointer is NULL for a combined table
+ * or points to an array of PyObject* for a split table
+ */
+typedef struct {
+    PyObject_HEAD
+
+    /* Number of items in the dictionary */
+    Py_ssize_t ma_used;
+
+    /* Dictionary version: globally unique, value change each time
+       the dictionary is modified */
+    uint64_t ma_version_tag;
+
+    PyDictKeysObject *ma_keys;
+
+    /* If ma_values is NULL, the table is "combined": keys and values
+       are stored in ma_keys.
+
+       If ma_values is not NULL, the table is split:
+       keys are stored in ma_keys and values are stored in ma_values */
+    PyObject **ma_values;
+} PyDictObject;
+
+PyAPI_FUNC(PyObject *) _PyDict_GetItem_KnownHash(PyObject *mp, PyObject *key,
+                                       Py_hash_t hash);
+PyAPI_FUNC(PyObject *) _PyDict_GetItemIdWithError(PyObject *dp,
+                                                  struct _Py_Identifier *key);
+PyAPI_FUNC(PyObject *) _PyDict_GetItemStringWithError(PyObject *, const char *);
+PyAPI_FUNC(PyObject *) PyDict_SetDefault(
+    PyObject *mp, PyObject *key, PyObject *defaultobj);
+PyAPI_FUNC(int) _PyDict_SetItem_KnownHash(PyObject *mp, PyObject *key,
+                                          PyObject *item, Py_hash_t hash);
+PyAPI_FUNC(int) _PyDict_DelItem_KnownHash(PyObject *mp, PyObject *key,
+                                          Py_hash_t hash);
+PyAPI_FUNC(int) _PyDict_DelItemIf(PyObject *mp, PyObject *key,
+                                  int (*predicate)(PyObject *value));
+PyDictKeysObject *_PyDict_NewKeysForClass(void);
+PyAPI_FUNC(PyObject *) PyObject_GenericGetDict(PyObject *, void *);
+PyAPI_FUNC(int) _PyDict_Next(
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, Py_hash_t *hash);
+
+/* Get the number of items of a dictionary. */
+#define PyDict_GET_SIZE(mp)  (assert(PyDict_Check(mp)),((PyDictObject *)mp)->ma_used)
+PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, Py_hash_t hash);
+PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused);
+PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp);
+PyAPI_FUNC(int) _PyDict_HasOnlyStringKeys(PyObject *mp);
+Py_ssize_t _PyDict_KeysSize(PyDictKeysObject *keys);
+PyAPI_FUNC(Py_ssize_t) _PyDict_SizeOf(PyDictObject *);
+PyAPI_FUNC(PyObject *) _PyDict_Pop(PyObject *, PyObject *, PyObject *);
+PyObject *_PyDict_Pop_KnownHash(PyObject *, PyObject *, Py_hash_t, PyObject *);
+PyObject *_PyDict_FromKeys(PyObject *, PyObject *, PyObject *);
+#define _PyDict_HasSplitTable(d) ((d)->ma_values != NULL)
+
+/* Like PyDict_Merge, but override can be 0, 1 or 2.  If override is 0,
+   the first occurrence of a key wins, if override is 1, the last occurrence
+   of a key wins, if override is 2, a KeyError with conflicting key as
+   argument is raised.
+*/
+PyAPI_FUNC(int) _PyDict_MergeEx(PyObject *mp, PyObject *other, int override);
+PyAPI_FUNC(PyObject *) _PyDict_GetItemId(PyObject *dp, struct _Py_Identifier *key);
+PyAPI_FUNC(int) _PyDict_SetItemId(PyObject *dp, struct _Py_Identifier *key, PyObject *item);
+
+PyAPI_FUNC(int) _PyDict_DelItemId(PyObject *mp, struct _Py_Identifier *key);
+PyAPI_FUNC(void) _PyDict_DebugMallocStats(FILE *out);
+
+int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject **dictptr, PyObject *name, PyObject *value);
+PyObject *_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *);
+
+/* _PyDictView */
+
+typedef struct {
+    PyObject_HEAD
+    PyDictObject *dv_dict;
+} _PyDictViewObject;
+
+PyAPI_FUNC(PyObject *) _PyDictView_New(PyObject *, PyTypeObject *);
+PyAPI_FUNC(PyObject *) _PyDictView_Intersect(PyObject* self, PyObject *other);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/fileobject.h b/marketing/include/cpython/fileobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..3005ce1f00f9d5b7644fde56fb064ade7abbff5f
--- /dev/null
+++ b/marketing/include/cpython/fileobject.h
@@ -0,0 +1,24 @@
+#ifndef Py_CPYTHON_FILEOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);
+
+/* The std printer acts as a preliminary sys.stderr until the new io
+   infrastructure is in place. */
+PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int);
+PyAPI_DATA(PyTypeObject) PyStdPrinter_Type;
+
+typedef PyObject * (*Py_OpenCodeHookFunction)(PyObject *, void *);
+
+PyAPI_FUNC(PyObject *) PyFile_OpenCode(const char *utf8path);
+PyAPI_FUNC(PyObject *) PyFile_OpenCodeObject(PyObject *path);
+PyAPI_FUNC(int) PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/fileutils.h b/marketing/include/cpython/fileutils.h
new file mode 100644
index 0000000000000000000000000000000000000000..e79d03e24f57714eefe1cc20ea907f965715d378
--- /dev/null
+++ b/marketing/include/cpython/fileutils.h
@@ -0,0 +1,165 @@
+#ifndef Py_CPYTHON_FILEUTILS_H
+#  error "this header file must not be included directly"
+#endif
+
+typedef enum {
+    _Py_ERROR_UNKNOWN=0,
+    _Py_ERROR_STRICT,
+    _Py_ERROR_SURROGATEESCAPE,
+    _Py_ERROR_REPLACE,
+    _Py_ERROR_IGNORE,
+    _Py_ERROR_BACKSLASHREPLACE,
+    _Py_ERROR_SURROGATEPASS,
+    _Py_ERROR_XMLCHARREFREPLACE,
+    _Py_ERROR_OTHER
+} _Py_error_handler;
+
+PyAPI_FUNC(_Py_error_handler) _Py_GetErrorHandler(const char *errors);
+
+PyAPI_FUNC(int) _Py_DecodeLocaleEx(
+    const char *arg,
+    wchar_t **wstr,
+    size_t *wlen,
+    const char **reason,
+    int current_locale,
+    _Py_error_handler errors);
+
+PyAPI_FUNC(int) _Py_EncodeLocaleEx(
+    const wchar_t *text,
+    char **str,
+    size_t *error_pos,
+    const char **reason,
+    int current_locale,
+    _Py_error_handler errors);
+
+
+PyAPI_FUNC(PyObject *) _Py_device_encoding(int);
+
+#if defined(MS_WINDOWS) || defined(__APPLE__)
+    /* On Windows, the count parameter of read() is an int (bpo-9015, bpo-9611).
+       On macOS 10.13, read() and write() with more than INT_MAX bytes
+       fail with EINVAL (bpo-24658). */
+#   define _PY_READ_MAX  INT_MAX
+#   define _PY_WRITE_MAX INT_MAX
+#else
+    /* write() should truncate the input to PY_SSIZE_T_MAX bytes,
+       but it's safer to do it ourself to have a portable behaviour */
+#   define _PY_READ_MAX  PY_SSIZE_T_MAX
+#   define _PY_WRITE_MAX PY_SSIZE_T_MAX
+#endif
+
+#ifdef MS_WINDOWS
+struct _Py_stat_struct {
+    unsigned long st_dev;
+    uint64_t st_ino;
+    unsigned short st_mode;
+    int st_nlink;
+    int st_uid;
+    int st_gid;
+    unsigned long st_rdev;
+    __int64 st_size;
+    time_t st_atime;
+    int st_atime_nsec;
+    time_t st_mtime;
+    int st_mtime_nsec;
+    time_t st_ctime;
+    int st_ctime_nsec;
+    unsigned long st_file_attributes;
+    unsigned long st_reparse_tag;
+};
+#else
+#  define _Py_stat_struct stat
+#endif
+
+PyAPI_FUNC(int) _Py_fstat(
+    int fd,
+    struct _Py_stat_struct *status);
+
+PyAPI_FUNC(int) _Py_fstat_noraise(
+    int fd,
+    struct _Py_stat_struct *status);
+
+PyAPI_FUNC(int) _Py_stat(
+    PyObject *path,
+    struct stat *status);
+
+PyAPI_FUNC(int) _Py_open(
+    const char *pathname,
+    int flags);
+
+PyAPI_FUNC(int) _Py_open_noraise(
+    const char *pathname,
+    int flags);
+
+PyAPI_FUNC(FILE *) _Py_wfopen(
+    const wchar_t *path,
+    const wchar_t *mode);
+
+PyAPI_FUNC(FILE*) _Py_fopen(
+    const char *pathname,
+    const char *mode);
+
+PyAPI_FUNC(FILE*) _Py_fopen_obj(
+    PyObject *path,
+    const char *mode);
+
+PyAPI_FUNC(Py_ssize_t) _Py_read(
+    int fd,
+    void *buf,
+    size_t count);
+
+PyAPI_FUNC(Py_ssize_t) _Py_write(
+    int fd,
+    const void *buf,
+    size_t count);
+
+PyAPI_FUNC(Py_ssize_t) _Py_write_noraise(
+    int fd,
+    const void *buf,
+    size_t count);
+
+#ifdef HAVE_READLINK
+PyAPI_FUNC(int) _Py_wreadlink(
+    const wchar_t *path,
+    wchar_t *buf,
+    /* Number of characters of 'buf' buffer
+       including the trailing NUL character */
+    size_t buflen);
+#endif
+
+#ifdef HAVE_REALPATH
+PyAPI_FUNC(wchar_t*) _Py_wrealpath(
+    const wchar_t *path,
+    wchar_t *resolved_path,
+    /* Number of characters of 'resolved_path' buffer
+       including the trailing NUL character */
+    size_t resolved_path_len);
+#endif
+
+#ifndef MS_WINDOWS
+PyAPI_FUNC(int) _Py_isabs(const wchar_t *path);
+#endif
+
+PyAPI_FUNC(int) _Py_abspath(const wchar_t *path, wchar_t **abspath_p);
+
+PyAPI_FUNC(wchar_t*) _Py_wgetcwd(
+    wchar_t *buf,
+    /* Number of characters of 'buf' buffer
+       including the trailing NUL character */
+    size_t buflen);
+
+PyAPI_FUNC(int) _Py_get_inheritable(int fd);
+
+PyAPI_FUNC(int) _Py_set_inheritable(int fd, int inheritable,
+                                    int *atomic_flag_works);
+
+PyAPI_FUNC(int) _Py_set_inheritable_async_safe(int fd, int inheritable,
+                                               int *atomic_flag_works);
+
+PyAPI_FUNC(int) _Py_dup(int fd);
+
+#ifndef MS_WINDOWS
+PyAPI_FUNC(int) _Py_get_blocking(int fd);
+
+PyAPI_FUNC(int) _Py_set_blocking(int fd, int blocking);
+#endif   /* !MS_WINDOWS */
diff --git a/marketing/include/cpython/frameobject.h b/marketing/include/cpython/frameobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..36a51baae8784bae26ab18169dce77ed4780edf9
--- /dev/null
+++ b/marketing/include/cpython/frameobject.h
@@ -0,0 +1,84 @@
+/* Frame object interface */
+
+#ifndef Py_CPYTHON_FRAMEOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    int b_type;                 /* what kind of block this is */
+    int b_handler;              /* where to jump to find handler */
+    int b_level;                /* value stack level to pop to */
+} PyTryBlock;
+
+struct _frame {
+    PyObject_VAR_HEAD
+    struct _frame *f_back;      /* previous frame, or NULL */
+    PyCodeObject *f_code;       /* code segment */
+    PyObject *f_builtins;       /* builtin symbol table (PyDictObject) */
+    PyObject *f_globals;        /* global symbol table (PyDictObject) */
+    PyObject *f_locals;         /* local symbol table (any mapping) */
+    PyObject **f_valuestack;    /* points after the last local */
+    /* Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
+       Frame evaluation usually NULLs it, but a frame that yields sets it
+       to the current stack top. */
+    PyObject **f_stacktop;
+    PyObject *f_trace;          /* Trace function */
+    char f_trace_lines;         /* Emit per-line trace events? */
+    char f_trace_opcodes;       /* Emit per-opcode trace events? */
+
+    /* Borrowed reference to a generator, or NULL */
+    PyObject *f_gen;
+
+    int f_lasti;                /* Last instruction if called */
+    /* Call PyFrame_GetLineNumber() instead of reading this field
+       directly.  As of 2.3 f_lineno is only valid when tracing is
+       active (i.e. when f_trace is set).  At other times we use
+       PyCode_Addr2Line to calculate the line from the current
+       bytecode index. */
+    int f_lineno;               /* Current line number */
+    int f_iblock;               /* index in f_blockstack */
+    char f_executing;           /* whether the frame is still executing */
+    PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
+    PyObject *f_localsplus[1];  /* locals+stack, dynamically sized */
+};
+
+
+/* Standard object interface */
+
+PyAPI_DATA(PyTypeObject) PyFrame_Type;
+
+#define PyFrame_Check(op) Py_IS_TYPE(op, &PyFrame_Type)
+
+PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *,
+                                        PyObject *, PyObject *);
+
+/* only internal use */
+PyFrameObject* _PyFrame_New_NoTrack(PyThreadState *, PyCodeObject *,
+                                    PyObject *, PyObject *);
+
+
+/* The rest of the interface is specific for frame objects */
+
+/* Block management functions */
+
+PyAPI_FUNC(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int);
+PyAPI_FUNC(PyTryBlock *) PyFrame_BlockPop(PyFrameObject *);
+
+/* Conversions between "fast locals" and locals in dictionary */
+
+PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int);
+
+PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f);
+PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *);
+
+PyAPI_FUNC(void) _PyFrame_DebugMallocStats(FILE *out);
+
+PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/import.h b/marketing/include/cpython/import.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1b47121f1246422759d4d0ffdd76522afb46e0d
--- /dev/null
+++ b/marketing/include/cpython/import.h
@@ -0,0 +1,50 @@
+#ifndef Py_CPYTHON_IMPORT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyMODINIT_FUNC PyInit__imp(void);
+
+PyAPI_FUNC(int) _PyImport_IsInitialized(PyInterpreterState *);
+
+PyAPI_FUNC(PyObject *) _PyImport_GetModuleId(struct _Py_Identifier *name);
+PyAPI_FUNC(int) _PyImport_SetModule(PyObject *name, PyObject *module);
+PyAPI_FUNC(int) _PyImport_SetModuleString(const char *name, PyObject* module);
+
+PyAPI_FUNC(void) _PyImport_AcquireLock(void);
+PyAPI_FUNC(int) _PyImport_ReleaseLock(void);
+
+PyAPI_FUNC(PyObject *) _PyImport_FindExtensionObject(PyObject *, PyObject *);
+
+PyAPI_FUNC(int) _PyImport_FixupBuiltin(
+    PyObject *mod,
+    const char *name,            /* UTF-8 encoded string */
+    PyObject *modules
+    );
+PyAPI_FUNC(int) _PyImport_FixupExtensionObject(PyObject*, PyObject *,
+                                               PyObject *, PyObject *);
+
+struct _inittab {
+    const char *name;           /* ASCII encoded string */
+    PyObject* (*initfunc)(void);
+};
+PyAPI_DATA(struct _inittab *) PyImport_Inittab;
+PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab);
+
+struct _frozen {
+    const char *name;                 /* ASCII encoded string */
+    const unsigned char *code;
+    int size;
+};
+
+/* Embedding apps may change this pointer to point to their favorite
+   collection of frozen modules: */
+
+PyAPI_DATA(const struct _frozen *) PyImport_FrozenModules;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/initconfig.h b/marketing/include/cpython/initconfig.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a256d4b5b0b8206dae4cc6a72493fe6195bd679
--- /dev/null
+++ b/marketing/include/cpython/initconfig.h
@@ -0,0 +1,462 @@
+#ifndef Py_PYCORECONFIG_H
+#define Py_PYCORECONFIG_H
+#ifndef Py_LIMITED_API
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* --- PyStatus ----------------------------------------------- */
+
+typedef struct {
+    enum {
+        _PyStatus_TYPE_OK=0,
+        _PyStatus_TYPE_ERROR=1,
+        _PyStatus_TYPE_EXIT=2
+    } _type;
+    const char *func;
+    const char *err_msg;
+    int exitcode;
+} PyStatus;
+
+PyAPI_FUNC(PyStatus) PyStatus_Ok(void);
+PyAPI_FUNC(PyStatus) PyStatus_Error(const char *err_msg);
+PyAPI_FUNC(PyStatus) PyStatus_NoMemory(void);
+PyAPI_FUNC(PyStatus) PyStatus_Exit(int exitcode);
+PyAPI_FUNC(int) PyStatus_IsError(PyStatus err);
+PyAPI_FUNC(int) PyStatus_IsExit(PyStatus err);
+PyAPI_FUNC(int) PyStatus_Exception(PyStatus err);
+
+/* --- PyWideStringList ------------------------------------------------ */
+
+typedef struct {
+    /* If length is greater than zero, items must be non-NULL
+       and all items strings must be non-NULL */
+    Py_ssize_t length;
+    wchar_t **items;
+} PyWideStringList;
+
+PyAPI_FUNC(PyStatus) PyWideStringList_Append(PyWideStringList *list,
+    const wchar_t *item);
+PyAPI_FUNC(PyStatus) PyWideStringList_Insert(PyWideStringList *list,
+    Py_ssize_t index,
+    const wchar_t *item);
+
+
+/* --- PyPreConfig ----------------------------------------------- */
+
+typedef struct {
+    int _config_init;     /* _PyConfigInitEnum value */
+
+    /* Parse Py_PreInitializeFromBytesArgs() arguments?
+       See PyConfig.parse_argv */
+    int parse_argv;
+
+    /* If greater than 0, enable isolated mode: sys.path contains
+       neither the script's directory nor the user's site-packages directory.
+
+       Set to 1 by the -I command line option. If set to -1 (default), inherit
+       Py_IsolatedFlag value. */
+    int isolated;
+
+    /* If greater than 0: use environment variables.
+       Set to 0 by -E command line option. If set to -1 (default), it is
+       set to !Py_IgnoreEnvironmentFlag. */
+    int use_environment;
+
+    /* Set the LC_CTYPE locale to the user preferred locale? If equals to 0,
+       set coerce_c_locale and coerce_c_locale_warn to 0. */
+    int configure_locale;
+
+    /* Coerce the LC_CTYPE locale if it's equal to "C"? (PEP 538)
+
+       Set to 0 by PYTHONCOERCECLOCALE=0. Set to 1 by PYTHONCOERCECLOCALE=1.
+       Set to 2 if the user preferred LC_CTYPE locale is "C".
+
+       If it is equal to 1, LC_CTYPE locale is read to decide if it should be
+       coerced or not (ex: PYTHONCOERCECLOCALE=1). Internally, it is set to 2
+       if the LC_CTYPE locale must be coerced.
+
+       Disable by default (set to 0). Set it to -1 to let Python decide if it
+       should be enabled or not. */
+    int coerce_c_locale;
+
+    /* Emit a warning if the LC_CTYPE locale is coerced?
+
+       Set to 1 by PYTHONCOERCECLOCALE=warn.
+
+       Disable by default (set to 0). Set it to -1 to let Python decide if it
+       should be enabled or not. */
+    int coerce_c_locale_warn;
+
+#ifdef MS_WINDOWS
+    /* If greater than 1, use the "mbcs" encoding instead of the UTF-8
+       encoding for the filesystem encoding.
+
+       Set to 1 if the PYTHONLEGACYWINDOWSFSENCODING environment variable is
+       set to a non-empty string. If set to -1 (default), inherit
+       Py_LegacyWindowsFSEncodingFlag value.
+
+       See PEP 529 for more details. */
+    int legacy_windows_fs_encoding;
+#endif
+
+    /* Enable UTF-8 mode? (PEP 540)
+
+       Disabled by default (equals to 0).
+
+       Set to 1 by "-X utf8" and "-X utf8=1" command line options.
+       Set to 1 by PYTHONUTF8=1 environment variable.
+
+       Set to 0 by "-X utf8=0" and PYTHONUTF8=0.
+
+       If equals to -1, it is set to 1 if the LC_CTYPE locale is "C" or
+       "POSIX", otherwise it is set to 0. Inherit Py_UTF8Mode value value. */
+    int utf8_mode;
+
+    /* If non-zero, enable the Python Development Mode.
+
+       Set to 1 by the -X dev command line option. Set by the PYTHONDEVMODE
+       environment variable. */
+    int dev_mode;
+
+    /* Memory allocator: PYTHONMALLOC env var.
+       See PyMemAllocatorName for valid values. */
+    int allocator;
+} PyPreConfig;
+
+PyAPI_FUNC(void) PyPreConfig_InitPythonConfig(PyPreConfig *config);
+PyAPI_FUNC(void) PyPreConfig_InitIsolatedConfig(PyPreConfig *config);
+
+
+/* --- PyConfig ---------------------------------------------- */
+
+typedef struct {
+    int _config_init;     /* _PyConfigInitEnum value */
+
+    int isolated;         /* Isolated mode? see PyPreConfig.isolated */
+    int use_environment;  /* Use environment variables? see PyPreConfig.use_environment */
+    int dev_mode;         /* Python Development Mode? See PyPreConfig.dev_mode */
+
+    /* Install signal handlers? Yes by default. */
+    int install_signal_handlers;
+
+    int use_hash_seed;      /* PYTHONHASHSEED=x */
+    unsigned long hash_seed;
+
+    /* Enable faulthandler?
+       Set to 1 by -X faulthandler and PYTHONFAULTHANDLER. -1 means unset. */
+    int faulthandler;
+
+    /* Enable PEG parser?
+       1 by default, set to 0 by -X oldparser and PYTHONOLDPARSER */
+    int _use_peg_parser;
+
+    /* Enable tracemalloc?
+       Set by -X tracemalloc=N and PYTHONTRACEMALLOC. -1 means unset */
+    int tracemalloc;
+
+    int import_time;        /* PYTHONPROFILEIMPORTTIME, -X importtime */
+    int show_ref_count;     /* -X showrefcount */
+    int dump_refs;          /* PYTHONDUMPREFS */
+    int malloc_stats;       /* PYTHONMALLOCSTATS */
+
+    /* Python filesystem encoding and error handler:
+       sys.getfilesystemencoding() and sys.getfilesystemencodeerrors().
+
+       Default encoding and error handler:
+
+       * if Py_SetStandardStreamEncoding() has been called: they have the
+         highest priority;
+       * PYTHONIOENCODING environment variable;
+       * The UTF-8 Mode uses UTF-8/surrogateescape;
+       * If Python forces the usage of the ASCII encoding (ex: C locale
+         or POSIX locale on FreeBSD or HP-UX), use ASCII/surrogateescape;
+       * locale encoding: ANSI code page on Windows, UTF-8 on Android and
+         VxWorks, LC_CTYPE locale encoding on other platforms;
+       * On Windows, "surrogateescape" error handler;
+       * "surrogateescape" error handler if the LC_CTYPE locale is "C" or "POSIX";
+       * "surrogateescape" error handler if the LC_CTYPE locale has been coerced
+         (PEP 538);
+       * "strict" error handler.
+
+       Supported error handlers: "strict", "surrogateescape" and
+       "surrogatepass". The surrogatepass error handler is only supported
+       if Py_DecodeLocale() and Py_EncodeLocale() use directly the UTF-8 codec;
+       it's only used on Windows.
+
+       initfsencoding() updates the encoding to the Python codec name.
+       For example, "ANSI_X3.4-1968" is replaced with "ascii".
+
+       On Windows, sys._enablelegacywindowsfsencoding() sets the
+       encoding/errors to mbcs/replace at runtime.
+
+
+       See Py_FileSystemDefaultEncoding and Py_FileSystemDefaultEncodeErrors.
+       */
+    wchar_t *filesystem_encoding;
+    wchar_t *filesystem_errors;
+
+    wchar_t *pycache_prefix;  /* PYTHONPYCACHEPREFIX, -X pycache_prefix=PATH */
+    int parse_argv;           /* Parse argv command line arguments? */
+
+    /* Command line arguments (sys.argv).
+
+       Set parse_argv to 1 to parse argv as Python command line arguments
+       and then strip Python arguments from argv.
+
+       If argv is empty, an empty string is added to ensure that sys.argv
+       always exists and is never empty. */
+    PyWideStringList argv;
+
+    /* Program name:
+
+       - If Py_SetProgramName() was called, use its value.
+       - On macOS, use PYTHONEXECUTABLE environment variable if set.
+       - If WITH_NEXT_FRAMEWORK macro is defined, use __PYVENV_LAUNCHER__
+         environment variable is set.
+       - Use argv[0] if available and non-empty.
+       - Use "python" on Windows, or "python3 on other platforms. */
+    wchar_t *program_name;
+
+    PyWideStringList xoptions;     /* Command line -X options */
+
+    /* Warnings options: lowest to highest priority. warnings.filters
+       is built in the reverse order (highest to lowest priority). */
+    PyWideStringList warnoptions;
+
+    /* If equal to zero, disable the import of the module site and the
+       site-dependent manipulations of sys.path that it entails. Also disable
+       these manipulations if site is explicitly imported later (call
+       site.main() if you want them to be triggered).
+
+       Set to 0 by the -S command line option. If set to -1 (default), it is
+       set to !Py_NoSiteFlag. */
+    int site_import;
+
+    /* Bytes warnings:
+
+       * If equal to 1, issue a warning when comparing bytes or bytearray with
+         str or bytes with int.
+       * If equal or greater to 2, issue an error.
+
+       Incremented by the -b command line option. If set to -1 (default), inherit
+       Py_BytesWarningFlag value. */
+    int bytes_warning;
+
+    /* If greater than 0, enable inspect: when a script is passed as first
+       argument or the -c option is used, enter interactive mode after
+       executing the script or the command, even when sys.stdin does not appear
+       to be a terminal.
+
+       Incremented by the -i command line option. Set to 1 if the PYTHONINSPECT
+       environment variable is non-empty. If set to -1 (default), inherit
+       Py_InspectFlag value. */
+    int inspect;
+
+    /* If greater than 0: enable the interactive mode (REPL).
+
+       Incremented by the -i command line option. If set to -1 (default),
+       inherit Py_InteractiveFlag value. */
+    int interactive;
+
+    /* Optimization level.
+
+       Incremented by the -O command line option. Set by the PYTHONOPTIMIZE
+       environment variable. If set to -1 (default), inherit Py_OptimizeFlag
+       value. */
+    int optimization_level;
+
+    /* If greater than 0, enable the debug mode: turn on parser debugging
+       output (for expert only, depending on compilation options).
+
+       Incremented by the -d command line option. Set by the PYTHONDEBUG
+       environment variable. If set to -1 (default), inherit Py_DebugFlag
+       value. */
+    int parser_debug;
+
+    /* If equal to 0, Python won't try to write ``.pyc`` files on the
+       import of source modules.
+
+       Set to 0 by the -B command line option and the PYTHONDONTWRITEBYTECODE
+       environment variable. If set to -1 (default), it is set to
+       !Py_DontWriteBytecodeFlag. */
+    int write_bytecode;
+
+    /* If greater than 0, enable the verbose mode: print a message each time a
+       module is initialized, showing the place (filename or built-in module)
+       from which it is loaded.
+
+       If greater or equal to 2, print a message for each file that is checked
+       for when searching for a module. Also provides information on module
+       cleanup at exit.
+
+       Incremented by the -v option. Set by the PYTHONVERBOSE environment
+       variable. If set to -1 (default), inherit Py_VerboseFlag value. */
+    int verbose;
+
+    /* If greater than 0, enable the quiet mode: Don't display the copyright
+       and version messages even in interactive mode.
+
+       Incremented by the -q option. If set to -1 (default), inherit
+       Py_QuietFlag value. */
+    int quiet;
+
+   /* If greater than 0, don't add the user site-packages directory to
+      sys.path.
+
+      Set to 0 by the -s and -I command line options , and the PYTHONNOUSERSITE
+      environment variable. If set to -1 (default), it is set to
+      !Py_NoUserSiteDirectory. */
+    int user_site_directory;
+
+    /* If non-zero, configure C standard steams (stdio, stdout,
+       stderr):
+
+       - Set O_BINARY mode on Windows.
+       - If buffered_stdio is equal to zero, make streams unbuffered.
+         Otherwise, enable streams buffering if interactive is non-zero. */
+    int configure_c_stdio;
+
+    /* If equal to 0, enable unbuffered mode: force the stdout and stderr
+       streams to be unbuffered.
+
+       Set to 0 by the -u option. Set by the PYTHONUNBUFFERED environment
+       variable.
+       If set to -1 (default), it is set to !Py_UnbufferedStdioFlag. */
+    int buffered_stdio;
+
+    /* Encoding of sys.stdin, sys.stdout and sys.stderr.
+       Value set from PYTHONIOENCODING environment variable and
+       Py_SetStandardStreamEncoding() function.
+       See also 'stdio_errors' attribute. */
+    wchar_t *stdio_encoding;
+
+    /* Error handler of sys.stdin and sys.stdout.
+       Value set from PYTHONIOENCODING environment variable and
+       Py_SetStandardStreamEncoding() function.
+       See also 'stdio_encoding' attribute. */
+    wchar_t *stdio_errors;
+
+#ifdef MS_WINDOWS
+    /* If greater than zero, use io.FileIO instead of WindowsConsoleIO for sys
+       standard streams.
+
+       Set to 1 if the PYTHONLEGACYWINDOWSSTDIO environment variable is set to
+       a non-empty string. If set to -1 (default), inherit
+       Py_LegacyWindowsStdioFlag value.
+
+       See PEP 528 for more details. */
+    int legacy_windows_stdio;
+#endif
+
+    /* Value of the --check-hash-based-pycs command line option:
+
+       - "default" means the 'check_source' flag in hash-based pycs
+         determines invalidation
+       - "always" causes the interpreter to hash the source file for
+         invalidation regardless of value of 'check_source' bit
+       - "never" causes the interpreter to always assume hash-based pycs are
+         valid
+
+       The default value is "default".
+
+       See PEP 552 "Deterministic pycs" for more details. */
+    wchar_t *check_hash_pycs_mode;
+
+    /* --- Path configuration inputs ------------ */
+
+    /* If greater than 0, suppress _PyPathConfig_Calculate() warnings on Unix.
+       The parameter has no effect on Windows.
+
+       If set to -1 (default), inherit !Py_FrozenFlag value. */
+    int pathconfig_warnings;
+
+    wchar_t *pythonpath_env; /* PYTHONPATH environment variable */
+    wchar_t *home;          /* PYTHONHOME environment variable,
+                               see also Py_SetPythonHome(). */
+
+    /* --- Path configuration outputs ----------- */
+
+    int module_search_paths_set;  /* If non-zero, use module_search_paths */
+    PyWideStringList module_search_paths;  /* sys.path paths. Computed if
+                                       module_search_paths_set is equal
+                                       to zero. */
+
+    wchar_t *executable;        /* sys.executable */
+    wchar_t *base_executable;   /* sys._base_executable */
+    wchar_t *prefix;            /* sys.prefix */
+    wchar_t *base_prefix;       /* sys.base_prefix */
+    wchar_t *exec_prefix;       /* sys.exec_prefix */
+    wchar_t *base_exec_prefix;  /* sys.base_exec_prefix */
+    wchar_t *platlibdir;        /* sys.platlibdir */
+
+    /* --- Parameter only used by Py_Main() ---------- */
+
+    /* Skip the first line of the source ('run_filename' parameter), allowing use of non-Unix forms of
+       "#!cmd".  This is intended for a DOS specific hack only.
+
+       Set by the -x command line option. */
+    int skip_source_first_line;
+
+    wchar_t *run_command;   /* -c command line argument */
+    wchar_t *run_module;    /* -m command line argument */
+    wchar_t *run_filename;  /* Trailing command line argument without -c or -m */
+
+    /* --- Private fields ---------------------------- */
+
+    /* Install importlib? If set to 0, importlib is not initialized at all.
+       Needed by freeze_importlib. */
+    int _install_importlib;
+
+    /* If equal to 0, stop Python initialization before the "main" phase */
+    int _init_main;
+
+    /* If non-zero, disallow threads, subprocesses, and fork.
+       Default: 0. */
+    int _isolated_interpreter;
+
+    /* Original command line arguments. If _orig_argv is empty and _argv is
+       not equal to [''], PyConfig_Read() copies the configuration 'argv' list
+       into '_orig_argv' list before modifying 'argv' list (if parse_argv
+       is non-zero).
+
+       _PyConfig_Write() initializes Py_GetArgcArgv() to this list. */
+    PyWideStringList _orig_argv;
+} PyConfig;
+
+PyAPI_FUNC(void) PyConfig_InitPythonConfig(PyConfig *config);
+PyAPI_FUNC(void) PyConfig_InitIsolatedConfig(PyConfig *config);
+PyAPI_FUNC(void) PyConfig_Clear(PyConfig *);
+PyAPI_FUNC(PyStatus) PyConfig_SetString(
+    PyConfig *config,
+    wchar_t **config_str,
+    const wchar_t *str);
+PyAPI_FUNC(PyStatus) PyConfig_SetBytesString(
+    PyConfig *config,
+    wchar_t **config_str,
+    const char *str);
+PyAPI_FUNC(PyStatus) PyConfig_Read(PyConfig *config);
+PyAPI_FUNC(PyStatus) PyConfig_SetBytesArgv(
+    PyConfig *config,
+    Py_ssize_t argc,
+    char * const *argv);
+PyAPI_FUNC(PyStatus) PyConfig_SetArgv(PyConfig *config,
+    Py_ssize_t argc,
+    wchar_t * const *argv);
+PyAPI_FUNC(PyStatus) PyConfig_SetWideStringList(PyConfig *config,
+    PyWideStringList *list,
+    Py_ssize_t length, wchar_t **items);
+
+
+/* --- Helper functions --------------------------------------- */
+
+/* Get the original command line arguments, before Python modified them.
+
+   See also PyConfig._orig_argv. */
+PyAPI_FUNC(void) Py_GetArgcArgv(int *argc, wchar_t ***argv);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_LIMITED_API */
+#endif /* !Py_PYCORECONFIG_H */
diff --git a/marketing/include/cpython/interpreteridobject.h b/marketing/include/cpython/interpreteridobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..67ec5873542d84765918ff0f9e76d17d4014d401
--- /dev/null
+++ b/marketing/include/cpython/interpreteridobject.h
@@ -0,0 +1,19 @@
+#ifndef Py_CPYTHON_INTERPRETERIDOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Interpreter ID Object */
+
+PyAPI_DATA(PyTypeObject) _PyInterpreterID_Type;
+
+PyAPI_FUNC(PyObject *) _PyInterpreterID_New(int64_t);
+PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *);
+PyAPI_FUNC(PyInterpreterState *) _PyInterpreterID_LookUp(PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/listobject.h b/marketing/include/cpython/listobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..74fe3301a7ab719faedba246790415cb1305b164
--- /dev/null
+++ b/marketing/include/cpython/listobject.h
@@ -0,0 +1,43 @@
+#ifndef Py_CPYTHON_LISTOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_VAR_HEAD
+    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
+    PyObject **ob_item;
+
+    /* ob_item contains space for 'allocated' elements.  The number
+     * currently in use is ob_size.
+     * Invariants:
+     *     0 <= ob_size <= allocated
+     *     len(list) == ob_size
+     *     ob_item == NULL implies ob_size == allocated == 0
+     * list.sort() temporarily sets allocated to -1 to detect mutations.
+     *
+     * Items must normally not be NULL, except during construction when
+     * the list is not yet visible outside the function that builds it.
+     */
+    Py_ssize_t allocated;
+} PyListObject;
+
+PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *);
+PyAPI_FUNC(void) _PyList_DebugMallocStats(FILE *out);
+
+/* Macro, trading safety for speed */
+
+/* Cast argument to PyTupleObject* type. */
+#define _PyList_CAST(op) (assert(PyList_Check(op)), (PyListObject *)(op))
+
+#define PyList_GET_ITEM(op, i) (_PyList_CAST(op)->ob_item[i])
+#define PyList_SET_ITEM(op, i, v) (_PyList_CAST(op)->ob_item[i] = (v))
+#define PyList_GET_SIZE(op)    Py_SIZE(_PyList_CAST(op))
+#define _PyList_ITEMS(op)      (_PyList_CAST(op)->ob_item)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/methodobject.h b/marketing/include/cpython/methodobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ecbfe3b5e2fe87d9482bd56f72b69fce37d6c26
--- /dev/null
+++ b/marketing/include/cpython/methodobject.h
@@ -0,0 +1,35 @@
+#ifndef Py_CPYTHON_METHODOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+PyAPI_DATA(PyTypeObject) PyCMethod_Type;
+
+#define PyCMethod_CheckExact(op) Py_IS_TYPE(op, &PyCMethod_Type)
+#define PyCMethod_Check(op) PyObject_TypeCheck(op, &PyCMethod_Type)
+
+/* Macros for direct access to these values. Type checks are *not*
+   done, so use with care. */
+#define PyCFunction_GET_FUNCTION(func) \
+        (((PyCFunctionObject *)func) -> m_ml -> ml_meth)
+#define PyCFunction_GET_SELF(func) \
+        (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_STATIC ? \
+         NULL : ((PyCFunctionObject *)func) -> m_self)
+#define PyCFunction_GET_FLAGS(func) \
+        (((PyCFunctionObject *)func) -> m_ml -> ml_flags)
+#define PyCFunction_GET_CLASS(func) \
+    (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_METHOD ? \
+         ((PyCMethodObject *)func) -> mm_class : NULL)
+
+typedef struct {
+    PyObject_HEAD
+    PyMethodDef *m_ml; /* Description of the C function to call */
+    PyObject    *m_self; /* Passed as 'self' arg to the C func, can be NULL */
+    PyObject    *m_module; /* The __module__ attribute, can be anything */
+    PyObject    *m_weakreflist; /* List of weak references */
+    vectorcallfunc vectorcall;
+} PyCFunctionObject;
+
+typedef struct {
+    PyCFunctionObject func;
+    PyTypeObject *mm_class; /* Class that defines this method */
+} PyCMethodObject;
diff --git a/marketing/include/cpython/object.h b/marketing/include/cpython/object.h
new file mode 100644
index 0000000000000000000000000000000000000000..444f832f5bd8d313250d2328d2fe7f8628e473d5
--- /dev/null
+++ b/marketing/include/cpython/object.h
@@ -0,0 +1,554 @@
+#ifndef Py_CPYTHON_OBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(void) _Py_NewReference(PyObject *op);
+
+#ifdef Py_TRACE_REFS
+/* Py_TRACE_REFS is such major surgery that we call external routines. */
+PyAPI_FUNC(void) _Py_ForgetReference(PyObject *);
+#endif
+
+/* Update the Python traceback of an object. This function must be called
+   when a memory block is reused from a free list. */
+PyAPI_FUNC(int) _PyTraceMalloc_NewReference(PyObject *op);
+
+#ifdef Py_REF_DEBUG
+PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void);
+#endif
+
+
+/********************* String Literals ****************************************/
+/* This structure helps managing static strings. The basic usage goes like this:
+   Instead of doing
+
+       r = PyObject_CallMethod(o, "foo", "args", ...);
+
+   do
+
+       _Py_IDENTIFIER(foo);
+       ...
+       r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...);
+
+   PyId_foo is a static variable, either on block level or file level. On first
+   usage, the string "foo" is interned, and the structures are linked. On interpreter
+   shutdown, all strings are released.
+
+   Alternatively, _Py_static_string allows choosing the variable name.
+   _PyUnicode_FromId returns a borrowed reference to the interned string.
+   _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*.
+*/
+typedef struct _Py_Identifier {
+    struct _Py_Identifier *next;
+    const char* string;
+    PyObject *object;
+} _Py_Identifier;
+
+#define _Py_static_string_init(value) { .next = NULL, .string = value, .object = NULL }
+#define _Py_static_string(varname, value)  static _Py_Identifier varname = _Py_static_string_init(value)
+#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname)
+
+/* buffer interface */
+typedef struct bufferinfo {
+    void *buf;
+    PyObject *obj;        /* owned reference */
+    Py_ssize_t len;
+    Py_ssize_t itemsize;  /* This is Py_ssize_t so it can be
+                             pointed to by strides in simple case.*/
+    int readonly;
+    int ndim;
+    char *format;
+    Py_ssize_t *shape;
+    Py_ssize_t *strides;
+    Py_ssize_t *suboffsets;
+    void *internal;
+} Py_buffer;
+
+typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
+typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
+
+typedef PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                    size_t nargsf, PyObject *kwnames);
+
+/* Maximum number of dimensions */
+#define PyBUF_MAX_NDIM 64
+
+/* Flags for getting buffers */
+#define PyBUF_SIMPLE 0
+#define PyBUF_WRITABLE 0x0001
+/*  we used to include an E, backwards compatible alias  */
+#define PyBUF_WRITEABLE PyBUF_WRITABLE
+#define PyBUF_FORMAT 0x0004
+#define PyBUF_ND 0x0008
+#define PyBUF_STRIDES (0x0010 | PyBUF_ND)
+#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)
+#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)
+#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)
+#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)
+
+#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE)
+#define PyBUF_CONTIG_RO (PyBUF_ND)
+
+#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE)
+#define PyBUF_STRIDED_RO (PyBUF_STRIDES)
+
+#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT)
+#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT)
+
+#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT)
+#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT)
+
+
+#define PyBUF_READ  0x100
+#define PyBUF_WRITE 0x200
+/* End buffer interface */
+
+
+typedef struct {
+    /* Number implementations must check *both*
+       arguments for proper type and implement the necessary conversions
+       in the slot functions themselves. */
+
+    binaryfunc nb_add;
+    binaryfunc nb_subtract;
+    binaryfunc nb_multiply;
+    binaryfunc nb_remainder;
+    binaryfunc nb_divmod;
+    ternaryfunc nb_power;
+    unaryfunc nb_negative;
+    unaryfunc nb_positive;
+    unaryfunc nb_absolute;
+    inquiry nb_bool;
+    unaryfunc nb_invert;
+    binaryfunc nb_lshift;
+    binaryfunc nb_rshift;
+    binaryfunc nb_and;
+    binaryfunc nb_xor;
+    binaryfunc nb_or;
+    unaryfunc nb_int;
+    void *nb_reserved;  /* the slot formerly known as nb_long */
+    unaryfunc nb_float;
+
+    binaryfunc nb_inplace_add;
+    binaryfunc nb_inplace_subtract;
+    binaryfunc nb_inplace_multiply;
+    binaryfunc nb_inplace_remainder;
+    ternaryfunc nb_inplace_power;
+    binaryfunc nb_inplace_lshift;
+    binaryfunc nb_inplace_rshift;
+    binaryfunc nb_inplace_and;
+    binaryfunc nb_inplace_xor;
+    binaryfunc nb_inplace_or;
+
+    binaryfunc nb_floor_divide;
+    binaryfunc nb_true_divide;
+    binaryfunc nb_inplace_floor_divide;
+    binaryfunc nb_inplace_true_divide;
+
+    unaryfunc nb_index;
+
+    binaryfunc nb_matrix_multiply;
+    binaryfunc nb_inplace_matrix_multiply;
+} PyNumberMethods;
+
+typedef struct {
+    lenfunc sq_length;
+    binaryfunc sq_concat;
+    ssizeargfunc sq_repeat;
+    ssizeargfunc sq_item;
+    void *was_sq_slice;
+    ssizeobjargproc sq_ass_item;
+    void *was_sq_ass_slice;
+    objobjproc sq_contains;
+
+    binaryfunc sq_inplace_concat;
+    ssizeargfunc sq_inplace_repeat;
+} PySequenceMethods;
+
+typedef struct {
+    lenfunc mp_length;
+    binaryfunc mp_subscript;
+    objobjargproc mp_ass_subscript;
+} PyMappingMethods;
+
+typedef struct {
+    unaryfunc am_await;
+    unaryfunc am_aiter;
+    unaryfunc am_anext;
+} PyAsyncMethods;
+
+typedef struct {
+     getbufferproc bf_getbuffer;
+     releasebufferproc bf_releasebuffer;
+} PyBufferProcs;
+
+/* Allow printfunc in the tp_vectorcall_offset slot for
+ * backwards-compatibility */
+typedef Py_ssize_t printfunc;
+
+struct _typeobject {
+    PyObject_VAR_HEAD
+    const char *tp_name; /* For printing, in format "." */
+    Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
+
+    /* Methods to implement standard operations */
+
+    destructor tp_dealloc;
+    Py_ssize_t tp_vectorcall_offset;
+    getattrfunc tp_getattr;
+    setattrfunc tp_setattr;
+    PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
+                                    or tp_reserved (Python 3) */
+    reprfunc tp_repr;
+
+    /* Method suites for standard classes */
+
+    PyNumberMethods *tp_as_number;
+    PySequenceMethods *tp_as_sequence;
+    PyMappingMethods *tp_as_mapping;
+
+    /* More standard operations (here for binary compatibility) */
+
+    hashfunc tp_hash;
+    ternaryfunc tp_call;
+    reprfunc tp_str;
+    getattrofunc tp_getattro;
+    setattrofunc tp_setattro;
+
+    /* Functions to access object as input/output buffer */
+    PyBufferProcs *tp_as_buffer;
+
+    /* Flags to define presence of optional/expanded features */
+    unsigned long tp_flags;
+
+    const char *tp_doc; /* Documentation string */
+
+    /* Assigned meaning in release 2.0 */
+    /* call function for all accessible objects */
+    traverseproc tp_traverse;
+
+    /* delete references to contained objects */
+    inquiry tp_clear;
+
+    /* Assigned meaning in release 2.1 */
+    /* rich comparisons */
+    richcmpfunc tp_richcompare;
+
+    /* weak reference enabler */
+    Py_ssize_t tp_weaklistoffset;
+
+    /* Iterators */
+    getiterfunc tp_iter;
+    iternextfunc tp_iternext;
+
+    /* Attribute descriptor and subclassing stuff */
+    struct PyMethodDef *tp_methods;
+    struct PyMemberDef *tp_members;
+    struct PyGetSetDef *tp_getset;
+    struct _typeobject *tp_base;
+    PyObject *tp_dict;
+    descrgetfunc tp_descr_get;
+    descrsetfunc tp_descr_set;
+    Py_ssize_t tp_dictoffset;
+    initproc tp_init;
+    allocfunc tp_alloc;
+    newfunc tp_new;
+    freefunc tp_free; /* Low-level free-memory routine */
+    inquiry tp_is_gc; /* For PyObject_IS_GC */
+    PyObject *tp_bases;
+    PyObject *tp_mro; /* method resolution order */
+    PyObject *tp_cache;
+    PyObject *tp_subclasses;
+    PyObject *tp_weaklist;
+    destructor tp_del;
+
+    /* Type attribute cache version tag. Added in version 2.6 */
+    unsigned int tp_version_tag;
+
+    destructor tp_finalize;
+    vectorcallfunc tp_vectorcall;
+};
+
+/* The *real* layout of a type object when allocated on the heap */
+typedef struct _heaptypeobject {
+    /* Note: there's a dependency on the order of these members
+       in slotptr() in typeobject.c . */
+    PyTypeObject ht_type;
+    PyAsyncMethods as_async;
+    PyNumberMethods as_number;
+    PyMappingMethods as_mapping;
+    PySequenceMethods as_sequence; /* as_sequence comes after as_mapping,
+                                      so that the mapping wins when both
+                                      the mapping and the sequence define
+                                      a given operator (e.g. __getitem__).
+                                      see add_operators() in typeobject.c . */
+    PyBufferProcs as_buffer;
+    PyObject *ht_name, *ht_slots, *ht_qualname;
+    struct _dictkeysobject *ht_cached_keys;
+    PyObject *ht_module;
+    /* here are optional user slots, followed by the members. */
+} PyHeapTypeObject;
+
+/* access macro to the members which are floating "behind" the object */
+#define PyHeapType_GET_MEMBERS(etype) \
+    ((PyMemberDef *)(((char *)etype) + Py_TYPE(etype)->tp_basicsize))
+
+PyAPI_FUNC(const char *) _PyType_Name(PyTypeObject *);
+PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *);
+PyAPI_FUNC(PyObject *) _PyType_LookupId(PyTypeObject *, _Py_Identifier *);
+PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, _Py_Identifier *);
+PyAPI_FUNC(PyTypeObject *) _PyType_CalculateMetaclass(PyTypeObject *, PyObject *);
+PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *);
+PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *);
+
+struct _Py_Identifier;
+PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int);
+PyAPI_FUNC(void) _Py_BreakPoint(void);
+PyAPI_FUNC(void) _PyObject_Dump(PyObject *);
+PyAPI_FUNC(int) _PyObject_IsFreed(PyObject *);
+
+PyAPI_FUNC(int) _PyObject_IsAbstract(PyObject *);
+PyAPI_FUNC(PyObject *) _PyObject_GetAttrId(PyObject *, struct _Py_Identifier *);
+PyAPI_FUNC(int) _PyObject_SetAttrId(PyObject *, struct _Py_Identifier *, PyObject *);
+PyAPI_FUNC(int) _PyObject_HasAttrId(PyObject *, struct _Py_Identifier *);
+/* Replacements of PyObject_GetAttr() and _PyObject_GetAttrId() which
+   don't raise AttributeError.
+
+   Return 1 and set *result != NULL if an attribute is found.
+   Return 0 and set *result == NULL if an attribute is not found;
+   an AttributeError is silenced.
+   Return -1 and set *result == NULL if an error other than AttributeError
+   is raised.
+*/
+PyAPI_FUNC(int) _PyObject_LookupAttr(PyObject *, PyObject *, PyObject **);
+PyAPI_FUNC(int) _PyObject_LookupAttrId(PyObject *, struct _Py_Identifier *, PyObject **);
+
+PyAPI_FUNC(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *);
+PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *);
+PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *);
+PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *);
+
+/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes
+   dict as the last parameter. */
+PyAPI_FUNC(PyObject *)
+_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *, int);
+PyAPI_FUNC(int)
+_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *,
+                                 PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) _PyObject_FunctionStr(PyObject *);
+
+/* Safely decref `op` and set `op` to `op2`.
+ *
+ * As in case of Py_CLEAR "the obvious" code can be deadly:
+ *
+ *     Py_DECREF(op);
+ *     op = op2;
+ *
+ * The safe way is:
+ *
+ *      Py_SETREF(op, op2);
+ *
+ * That arranges to set `op` to `op2` _before_ decref'ing, so that any code
+ * triggered as a side-effect of `op` getting torn down no longer believes
+ * `op` points to a valid object.
+ *
+ * Py_XSETREF is a variant of Py_SETREF that uses Py_XDECREF instead of
+ * Py_DECREF.
+ */
+
+#define Py_SETREF(op, op2)                      \
+    do {                                        \
+        PyObject *_py_tmp = _PyObject_CAST(op); \
+        (op) = (op2);                           \
+        Py_DECREF(_py_tmp);                     \
+    } while (0)
+
+#define Py_XSETREF(op, op2)                     \
+    do {                                        \
+        PyObject *_py_tmp = _PyObject_CAST(op); \
+        (op) = (op2);                           \
+        Py_XDECREF(_py_tmp);                    \
+    } while (0)
+
+
+PyAPI_DATA(PyTypeObject) _PyNone_Type;
+PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type;
+
+/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE.
+ * Defined in object.c.
+ */
+PyAPI_DATA(int) _Py_SwappedOp[];
+
+PyAPI_FUNC(void)
+_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks,
+                       size_t sizeof_block);
+PyAPI_FUNC(void)
+_PyObject_DebugTypeStats(FILE *out);
+
+/* Define a pair of assertion macros:
+   _PyObject_ASSERT_FROM(), _PyObject_ASSERT_WITH_MSG() and _PyObject_ASSERT().
+
+   These work like the regular C assert(), in that they will abort the
+   process with a message on stderr if the given condition fails to hold,
+   but compile away to nothing if NDEBUG is defined.
+
+   However, before aborting, Python will also try to call _PyObject_Dump() on
+   the given object.  This may be of use when investigating bugs in which a
+   particular object is corrupt (e.g. buggy a tp_visit method in an extension
+   module breaking the garbage collector), to help locate the broken objects.
+
+   The WITH_MSG variant allows you to supply an additional message that Python
+   will attempt to print to stderr, after the object dump. */
+#ifdef NDEBUG
+   /* No debugging: compile away the assertions: */
+#  define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \
+    ((void)0)
+#else
+   /* With debugging: generate checks: */
+#  define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \
+    ((expr) \
+      ? (void)(0) \
+      : _PyObject_AssertFailed((obj), Py_STRINGIFY(expr), \
+                               (msg), (filename), (lineno), (func)))
+#endif
+
+#define _PyObject_ASSERT_WITH_MSG(obj, expr, msg) \
+    _PyObject_ASSERT_FROM(obj, expr, msg, __FILE__, __LINE__, __func__)
+#define _PyObject_ASSERT(obj, expr) \
+    _PyObject_ASSERT_WITH_MSG(obj, expr, NULL)
+
+#define _PyObject_ASSERT_FAILED_MSG(obj, msg) \
+    _PyObject_AssertFailed((obj), NULL, (msg), __FILE__, __LINE__, __func__)
+
+/* Declare and define _PyObject_AssertFailed() even when NDEBUG is defined,
+   to avoid causing compiler/linker errors when building extensions without
+   NDEBUG against a Python built with NDEBUG defined.
+
+   msg, expr and function can be NULL. */
+PyAPI_FUNC(void) _Py_NO_RETURN _PyObject_AssertFailed(
+    PyObject *obj,
+    const char *expr,
+    const char *msg,
+    const char *file,
+    int line,
+    const char *function);
+
+/* Check if an object is consistent. For example, ensure that the reference
+   counter is greater than or equal to 1, and ensure that ob_type is not NULL.
+
+   Call _PyObject_AssertFailed() if the object is inconsistent.
+
+   If check_content is zero, only check header fields: reduce the overhead.
+
+   The function always return 1. The return value is just here to be able to
+   write:
+
+   assert(_PyObject_CheckConsistency(obj, 1)); */
+PyAPI_FUNC(int) _PyObject_CheckConsistency(
+    PyObject *op,
+    int check_content);
+
+
+/* Trashcan mechanism, thanks to Christian Tismer.
+
+When deallocating a container object, it's possible to trigger an unbounded
+chain of deallocations, as each Py_DECREF in turn drops the refcount on "the
+next" object in the chain to 0.  This can easily lead to stack overflows,
+especially in threads (which typically have less stack space to work with).
+
+A container object can avoid this by bracketing the body of its tp_dealloc
+function with a pair of macros:
+
+static void
+mytype_dealloc(mytype *p)
+{
+    ... declarations go here ...
+
+    PyObject_GC_UnTrack(p);        // must untrack first
+    Py_TRASHCAN_BEGIN(p, mytype_dealloc)
+    ... The body of the deallocator goes here, including all calls ...
+    ... to Py_DECREF on contained objects.                         ...
+    Py_TRASHCAN_END                // there should be no code after this
+}
+
+CAUTION:  Never return from the middle of the body!  If the body needs to
+"get out early", put a label immediately before the Py_TRASHCAN_END
+call, and goto it.  Else the call-depth counter (see below) will stay
+above 0 forever, and the trashcan will never get emptied.
+
+How it works:  The BEGIN macro increments a call-depth counter.  So long
+as this counter is small, the body of the deallocator is run directly without
+further ado.  But if the counter gets large, it instead adds p to a list of
+objects to be deallocated later, skips the body of the deallocator, and
+resumes execution after the END macro.  The tp_dealloc routine then returns
+without deallocating anything (and so unbounded call-stack depth is avoided).
+
+When the call stack finishes unwinding again, code generated by the END macro
+notices this, and calls another routine to deallocate all the objects that
+may have been added to the list of deferred deallocations.  In effect, a
+chain of N deallocations is broken into (N-1)/(PyTrash_UNWIND_LEVEL-1) pieces,
+with the call stack never exceeding a depth of PyTrash_UNWIND_LEVEL.
+
+Since the tp_dealloc of a subclass typically calls the tp_dealloc of the base
+class, we need to ensure that the trashcan is only triggered on the tp_dealloc
+of the actual class being deallocated. Otherwise we might end up with a
+partially-deallocated object. To check this, the tp_dealloc function must be
+passed as second argument to Py_TRASHCAN_BEGIN().
+*/
+
+/* This is the old private API, invoked by the macros before 3.2.4.
+   Kept for binary compatibility of extensions using the stable ABI. */
+PyAPI_FUNC(void) _PyTrash_deposit_object(PyObject*);
+PyAPI_FUNC(void) _PyTrash_destroy_chain(void);
+
+/* This is the old private API, invoked by the macros before 3.9.
+   Kept for binary compatibility of extensions using the stable ABI. */
+PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyObject*);
+PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(void);
+
+/* Forward declarations for PyThreadState */
+struct _ts;
+
+/* Python 3.9 private API, invoked by the macros below. */
+PyAPI_FUNC(int) _PyTrash_begin(struct _ts *tstate, PyObject *op);
+PyAPI_FUNC(void) _PyTrash_end(struct _ts *tstate);
+
+#define PyTrash_UNWIND_LEVEL 50
+
+#define Py_TRASHCAN_BEGIN_CONDITION(op, cond) \
+    do { \
+        PyThreadState *_tstate = NULL; \
+        /* If "cond" is false, then _tstate remains NULL and the deallocator \
+         * is run normally without involving the trashcan */ \
+        if (cond) { \
+            _tstate = PyThreadState_GET(); \
+            if (_PyTrash_begin(_tstate, _PyObject_CAST(op))) { \
+                break; \
+            } \
+        }
+        /* The body of the deallocator is here. */
+#define Py_TRASHCAN_END \
+        if (_tstate) { \
+            _PyTrash_end(_tstate); \
+        } \
+    } while (0);
+
+#define Py_TRASHCAN_BEGIN(op, dealloc) \
+    Py_TRASHCAN_BEGIN_CONDITION(op, \
+        Py_TYPE(op)->tp_dealloc == (destructor)(dealloc))
+
+/* For backwards compatibility, these macros enable the trashcan
+ * unconditionally */
+#define Py_TRASHCAN_SAFE_BEGIN(op) Py_TRASHCAN_BEGIN_CONDITION(op, 1)
+#define Py_TRASHCAN_SAFE_END(op) Py_TRASHCAN_END
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/objimpl.h b/marketing/include/cpython/objimpl.h
new file mode 100644
index 0000000000000000000000000000000000000000..b835936db701120c562d35bfd6b7bbacfa9009f6
--- /dev/null
+++ b/marketing/include/cpython/objimpl.h
@@ -0,0 +1,145 @@
+#ifndef Py_CPYTHON_OBJIMPL_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize )
+
+/* _PyObject_VAR_SIZE returns the number of bytes (as size_t) allocated for a
+   vrbl-size object with nitems items, exclusive of gc overhead (if any).  The
+   value is rounded up to the closest multiple of sizeof(void *), in order to
+   ensure that pointer fields at the end of the object are correctly aligned
+   for the platform (this is of special importance for subclasses of, e.g.,
+   str or int, so that pointers can be stored after the embedded data).
+
+   Note that there's no memory wastage in doing this, as malloc has to
+   return (at worst) pointer-aligned memory anyway.
+*/
+#if ((SIZEOF_VOID_P - 1) & SIZEOF_VOID_P) != 0
+#   error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2"
+#endif
+
+#define _PyObject_VAR_SIZE(typeobj, nitems)     \
+    _Py_SIZE_ROUND_UP((typeobj)->tp_basicsize + \
+        (nitems)*(typeobj)->tp_itemsize,        \
+        SIZEOF_VOID_P)
+
+
+/* This example code implements an object constructor with a custom
+   allocator, where PyObject_New is inlined, and shows the important
+   distinction between two steps (at least):
+       1) the actual allocation of the object storage;
+       2) the initialization of the Python specific fields
+      in this storage with PyObject_{Init, InitVar}.
+
+   PyObject *
+   YourObject_New(...)
+   {
+       PyObject *op;
+
+       op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct));
+       if (op == NULL)
+       return PyErr_NoMemory();
+
+       PyObject_Init(op, &YourTypeStruct);
+
+       op->ob_field = value;
+       ...
+       return op;
+   }
+
+   Note that in C++, the use of the new operator usually implies that
+   the 1st step is performed automatically for you, so in a C++ class
+   constructor you would start directly with PyObject_Init/InitVar. */
+
+
+/* Inline functions trading binary compatibility for speed:
+   PyObject_INIT() is the fast version of PyObject_Init(), and
+   PyObject_INIT_VAR() is the fast version of PyObject_InitVar().
+
+   These inline functions must not be called with op=NULL. */
+static inline PyObject*
+_PyObject_INIT(PyObject *op, PyTypeObject *typeobj)
+{
+    assert(op != NULL);
+    Py_SET_TYPE(op, typeobj);
+    if (PyType_GetFlags(typeobj) & Py_TPFLAGS_HEAPTYPE) {
+        Py_INCREF(typeobj);
+    }
+    _Py_NewReference(op);
+    return op;
+}
+
+#define PyObject_INIT(op, typeobj) \
+    _PyObject_INIT(_PyObject_CAST(op), (typeobj))
+
+static inline PyVarObject*
+_PyObject_INIT_VAR(PyVarObject *op, PyTypeObject *typeobj, Py_ssize_t size)
+{
+    assert(op != NULL);
+    Py_SET_SIZE(op, size);
+    PyObject_INIT((PyObject *)op, typeobj);
+    return op;
+}
+
+#define PyObject_INIT_VAR(op, typeobj, size) \
+    _PyObject_INIT_VAR(_PyVarObject_CAST(op), (typeobj), (size))
+
+
+/* This function returns the number of allocated memory blocks, regardless of size */
+PyAPI_FUNC(Py_ssize_t) _Py_GetAllocatedBlocks(void);
+
+/* Macros */
+#ifdef WITH_PYMALLOC
+PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE *out);
+#endif
+
+
+typedef struct {
+    /* user context passed as the first argument to the 2 functions */
+    void *ctx;
+
+    /* allocate an arena of size bytes */
+    void* (*alloc) (void *ctx, size_t size);
+
+    /* free an arena */
+    void (*free) (void *ctx, void *ptr, size_t size);
+} PyObjectArenaAllocator;
+
+/* Get the arena allocator. */
+PyAPI_FUNC(void) PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator);
+
+/* Set the arena allocator. */
+PyAPI_FUNC(void) PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator);
+
+
+PyAPI_FUNC(Py_ssize_t) _PyGC_CollectNoFail(void);
+PyAPI_FUNC(Py_ssize_t) _PyGC_CollectIfEnabled(void);
+
+
+/* Test if an object implements the garbage collector protocol */
+PyAPI_FUNC(int) PyObject_IS_GC(PyObject *obj);
+
+
+/* Code built with Py_BUILD_CORE must include pycore_gc.h instead which
+   defines a different _PyGC_FINALIZED() macro. */
+#ifndef Py_BUILD_CORE
+   // Kept for backward compatibility with Python 3.8
+#  define _PyGC_FINALIZED(o) PyObject_GC_IsFinalized(o)
+#endif
+
+PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t size);
+PyAPI_FUNC(PyObject *) _PyObject_GC_Calloc(size_t size);
+
+
+/* Test if a type supports weak references */
+#define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0)
+
+PyAPI_FUNC(PyObject **) PyObject_GET_WEAKREFS_LISTPTR(PyObject *op);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/pyerrors.h b/marketing/include/cpython/pyerrors.h
new file mode 100644
index 0000000000000000000000000000000000000000..9c87b53979024d6c3eaf2fd64b374e84b284e43c
--- /dev/null
+++ b/marketing/include/cpython/pyerrors.h
@@ -0,0 +1,200 @@
+#ifndef Py_CPYTHON_ERRORS_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Error objects */
+
+/* PyException_HEAD defines the initial segment of every exception class. */
+#define PyException_HEAD PyObject_HEAD PyObject *dict;\
+             PyObject *args; PyObject *traceback;\
+             PyObject *context; PyObject *cause;\
+             char suppress_context;
+
+typedef struct {
+    PyException_HEAD
+} PyBaseExceptionObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *msg;
+    PyObject *filename;
+    PyObject *lineno;
+    PyObject *offset;
+    PyObject *text;
+    PyObject *print_file_and_line;
+} PySyntaxErrorObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *msg;
+    PyObject *name;
+    PyObject *path;
+} PyImportErrorObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *encoding;
+    PyObject *object;
+    Py_ssize_t start;
+    Py_ssize_t end;
+    PyObject *reason;
+} PyUnicodeErrorObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *code;
+} PySystemExitObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *myerrno;
+    PyObject *strerror;
+    PyObject *filename;
+    PyObject *filename2;
+#ifdef MS_WINDOWS
+    PyObject *winerror;
+#endif
+    Py_ssize_t written;   /* only for BlockingIOError, -1 otherwise */
+} PyOSErrorObject;
+
+typedef struct {
+    PyException_HEAD
+    PyObject *value;
+} PyStopIterationObject;
+
+/* Compatibility typedefs */
+typedef PyOSErrorObject PyEnvironmentErrorObject;
+#ifdef MS_WINDOWS
+typedef PyOSErrorObject PyWindowsErrorObject;
+#endif
+
+/* Error handling definitions */
+
+PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *);
+PyAPI_FUNC(_PyErr_StackItem*) _PyErr_GetTopmostException(PyThreadState *tstate);
+PyAPI_FUNC(void) _PyErr_GetExcInfo(PyThreadState *, PyObject **, PyObject **, PyObject **);
+
+/* Context manipulation (PEP 3134) */
+
+PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *);
+
+/* */
+
+#define PyExceptionClass_Name(x)  (((PyTypeObject*)(x))->tp_name)
+
+/* Convenience functions */
+
+#ifdef MS_WINDOWS
+Py_DEPRECATED(3.3)
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename(
+    PyObject *, const Py_UNICODE *);
+#endif /* MS_WINDOWS */
+
+/* Like PyErr_Format(), but saves current exception as __context__ and
+   __cause__.
+ */
+PyAPI_FUNC(PyObject *) _PyErr_FormatFromCause(
+    PyObject *exception,
+    const char *format,   /* ASCII-encoded string  */
+    ...
+    );
+
+#ifdef MS_WINDOWS
+/* XXX redeclare to use WSTRING */
+Py_DEPRECATED(3.3)
+PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename(
+    int, const Py_UNICODE *);
+Py_DEPRECATED(3.3)
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename(
+    PyObject *,int, const Py_UNICODE *);
+#endif
+
+/* In exceptions.c */
+
+/* Helper that attempts to replace the current exception with one of the
+ * same type but with a prefix added to the exception text. The resulting
+ * exception description looks like:
+ *
+ *     prefix (exc_type: original_exc_str)
+ *
+ * Only some exceptions can be safely replaced. If the function determines
+ * it isn't safe to perform the replacement, it will leave the original
+ * unmodified exception in place.
+ *
+ * Returns a borrowed reference to the new exception (if any), NULL if the
+ * existing exception was left in place.
+ */
+PyAPI_FUNC(PyObject *) _PyErr_TrySetFromCause(
+    const char *prefix_format,   /* ASCII-encoded string  */
+    ...
+    );
+
+/* In signalmodule.c */
+
+int PySignal_SetWakeupFd(int fd);
+PyAPI_FUNC(int) _PyErr_CheckSignals(void);
+
+/* Support for adding program text to SyntaxErrors */
+
+PyAPI_FUNC(void) PyErr_SyntaxLocationObject(
+    PyObject *filename,
+    int lineno,
+    int col_offset);
+
+PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject(
+    PyObject *filename,
+    int lineno);
+
+/* Create a UnicodeEncodeError object.
+ *
+ * TODO: This API will be removed in Python 3.11.
+ */
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create(
+    const char *encoding,       /* UTF-8 encoded string */
+    const Py_UNICODE *object,
+    Py_ssize_t length,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    const char *reason          /* UTF-8 encoded string */
+    );
+
+/* Create a UnicodeTranslateError object.
+ *
+ * TODO: This API will be removed in Python 3.11.
+ */
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create(
+    const Py_UNICODE *object,
+    Py_ssize_t length,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    const char *reason          /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(PyObject *) _PyUnicodeTranslateError_Create(
+    PyObject *object,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    const char *reason          /* UTF-8 encoded string */
+    );
+
+PyAPI_FUNC(void) _PyErr_WriteUnraisableMsg(
+    const char *err_msg,
+    PyObject *obj);
+
+PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFunc(
+    const char *func,
+    const char *message);
+
+PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFormat(
+    const char *func,
+    const char *format,
+    ...);
+
+#define Py_FatalError(message) _Py_FatalErrorFunc(__func__, message)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/pylifecycle.h b/marketing/include/cpython/pylifecycle.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb523b82e182d8c4018661ed8ea7c9e2e587efb8
--- /dev/null
+++ b/marketing/include/cpython/pylifecycle.h
@@ -0,0 +1,72 @@
+#ifndef Py_CPYTHON_PYLIFECYCLE_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Only used by applications that embed the interpreter and need to
+ * override the standard encoding determination mechanism
+ */
+PyAPI_FUNC(int) Py_SetStandardStreamEncoding(const char *encoding,
+                                             const char *errors);
+
+/* PEP 432 Multi-phase initialization API (Private while provisional!) */
+
+PyAPI_FUNC(PyStatus) Py_PreInitialize(
+    const PyPreConfig *src_config);
+PyAPI_FUNC(PyStatus) Py_PreInitializeFromBytesArgs(
+    const PyPreConfig *src_config,
+    Py_ssize_t argc,
+    char **argv);
+PyAPI_FUNC(PyStatus) Py_PreInitializeFromArgs(
+    const PyPreConfig *src_config,
+    Py_ssize_t argc,
+    wchar_t **argv);
+
+PyAPI_FUNC(int) _Py_IsCoreInitialized(void);
+
+
+/* Initialization and finalization */
+
+PyAPI_FUNC(PyStatus) Py_InitializeFromConfig(
+    const PyConfig *config);
+PyAPI_FUNC(PyStatus) _Py_InitializeMain(void);
+
+PyAPI_FUNC(int) Py_RunMain(void);
+
+
+PyAPI_FUNC(void) _Py_NO_RETURN Py_ExitStatusException(PyStatus err);
+
+/* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level
+ * exit functions.
+ */
+PyAPI_FUNC(void) _Py_PyAtExit(void (*func)(PyObject *), PyObject *);
+
+/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. */
+PyAPI_FUNC(void) _Py_RestoreSignals(void);
+
+PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *);
+
+PyAPI_FUNC(void) _Py_SetProgramFullPath(const wchar_t *);
+
+PyAPI_FUNC(const char *) _Py_gitidentifier(void);
+PyAPI_FUNC(const char *) _Py_gitversion(void);
+
+PyAPI_FUNC(int) _Py_IsFinalizing(void);
+
+/* Random */
+PyAPI_FUNC(int) _PyOS_URandom(void *buffer, Py_ssize_t size);
+PyAPI_FUNC(int) _PyOS_URandomNonblock(void *buffer, Py_ssize_t size);
+
+/* Legacy locale support */
+PyAPI_FUNC(int) _Py_CoerceLegacyLocale(int warn);
+PyAPI_FUNC(int) _Py_LegacyLocaleDetected(int warn);
+PyAPI_FUNC(char *) _Py_SetLocaleFromEnv(int category);
+
+PyAPI_FUNC(PyThreadState *) _Py_NewInterpreter(int isolated_subinterpreter);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/pymem.h b/marketing/include/cpython/pymem.h
new file mode 100644
index 0000000000000000000000000000000000000000..79f063b1217534b8f3fc0b494ec55f3736f33f81
--- /dev/null
+++ b/marketing/include/cpython/pymem.h
@@ -0,0 +1,108 @@
+#ifndef Py_CPYTHON_PYMEM_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(void *) PyMem_RawMalloc(size_t size);
+PyAPI_FUNC(void *) PyMem_RawCalloc(size_t nelem, size_t elsize);
+PyAPI_FUNC(void *) PyMem_RawRealloc(void *ptr, size_t new_size);
+PyAPI_FUNC(void) PyMem_RawFree(void *ptr);
+
+/* Try to get the allocators name set by _PyMem_SetupAllocators(). */
+PyAPI_FUNC(const char*) _PyMem_GetCurrentAllocatorName(void);
+
+PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize);
+
+/* strdup() using PyMem_RawMalloc() */
+PyAPI_FUNC(char *) _PyMem_RawStrdup(const char *str);
+
+/* strdup() using PyMem_Malloc() */
+PyAPI_FUNC(char *) _PyMem_Strdup(const char *str);
+
+/* wcsdup() using PyMem_RawMalloc() */
+PyAPI_FUNC(wchar_t*) _PyMem_RawWcsdup(const wchar_t *str);
+
+
+typedef enum {
+    /* PyMem_RawMalloc(), PyMem_RawRealloc() and PyMem_RawFree() */
+    PYMEM_DOMAIN_RAW,
+
+    /* PyMem_Malloc(), PyMem_Realloc() and PyMem_Free() */
+    PYMEM_DOMAIN_MEM,
+
+    /* PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() */
+    PYMEM_DOMAIN_OBJ
+} PyMemAllocatorDomain;
+
+typedef enum {
+    PYMEM_ALLOCATOR_NOT_SET = 0,
+    PYMEM_ALLOCATOR_DEFAULT = 1,
+    PYMEM_ALLOCATOR_DEBUG = 2,
+    PYMEM_ALLOCATOR_MALLOC = 3,
+    PYMEM_ALLOCATOR_MALLOC_DEBUG = 4,
+#ifdef WITH_PYMALLOC
+    PYMEM_ALLOCATOR_PYMALLOC = 5,
+    PYMEM_ALLOCATOR_PYMALLOC_DEBUG = 6,
+#endif
+} PyMemAllocatorName;
+
+
+typedef struct {
+    /* user context passed as the first argument to the 4 functions */
+    void *ctx;
+
+    /* allocate a memory block */
+    void* (*malloc) (void *ctx, size_t size);
+
+    /* allocate a memory block initialized by zeros */
+    void* (*calloc) (void *ctx, size_t nelem, size_t elsize);
+
+    /* allocate or resize a memory block */
+    void* (*realloc) (void *ctx, void *ptr, size_t new_size);
+
+    /* release a memory block */
+    void (*free) (void *ctx, void *ptr);
+} PyMemAllocatorEx;
+
+/* Get the memory block allocator of the specified domain. */
+PyAPI_FUNC(void) PyMem_GetAllocator(PyMemAllocatorDomain domain,
+                                    PyMemAllocatorEx *allocator);
+
+/* Set the memory block allocator of the specified domain.
+
+   The new allocator must return a distinct non-NULL pointer when requesting
+   zero bytes.
+
+   For the PYMEM_DOMAIN_RAW domain, the allocator must be thread-safe: the GIL
+   is not held when the allocator is called.
+
+   If the new allocator is not a hook (don't call the previous allocator), the
+   PyMem_SetupDebugHooks() function must be called to reinstall the debug hooks
+   on top on the new allocator. */
+PyAPI_FUNC(void) PyMem_SetAllocator(PyMemAllocatorDomain domain,
+                                    PyMemAllocatorEx *allocator);
+
+/* Setup hooks to detect bugs in the following Python memory allocator
+   functions:
+
+   - PyMem_RawMalloc(), PyMem_RawRealloc(), PyMem_RawFree()
+   - PyMem_Malloc(), PyMem_Realloc(), PyMem_Free()
+   - PyObject_Malloc(), PyObject_Realloc() and PyObject_Free()
+
+   Newly allocated memory is filled with the byte 0xCB, freed memory is filled
+   with the byte 0xDB. Additional checks:
+
+   - detect API violations, ex: PyObject_Free() called on a buffer allocated
+     by PyMem_Malloc()
+   - detect write before the start of the buffer (buffer underflow)
+   - detect write after the end of the buffer (buffer overflow)
+
+   The function does nothing if Python is not compiled is debug mode. */
+PyAPI_FUNC(void) PyMem_SetupDebugHooks(void);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/pystate.h b/marketing/include/cpython/pystate.h
new file mode 100644
index 0000000000000000000000000000000000000000..0eb601fd7c55ece76d5f75cb94af9fd0921efc5c
--- /dev/null
+++ b/marketing/include/cpython/pystate.h
@@ -0,0 +1,261 @@
+#ifndef Py_CPYTHON_PYSTATE_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(int) _PyInterpreterState_RequiresIDRef(PyInterpreterState *);
+PyAPI_FUNC(void) _PyInterpreterState_RequireIDRef(PyInterpreterState *, int);
+
+PyAPI_FUNC(PyObject *) _PyInterpreterState_GetMainModule(PyInterpreterState *);
+
+/* State unique per thread */
+
+/* Py_tracefunc return -1 when raising an exception, or 0 for success. */
+typedef int (*Py_tracefunc)(PyObject *, PyFrameObject *, int, PyObject *);
+
+/* The following values are used for 'what' for tracefunc functions
+ *
+ * To add a new kind of trace event, also update "trace_init" in
+ * Python/sysmodule.c to define the Python level event name
+ */
+#define PyTrace_CALL 0
+#define PyTrace_EXCEPTION 1
+#define PyTrace_LINE 2
+#define PyTrace_RETURN 3
+#define PyTrace_C_CALL 4
+#define PyTrace_C_EXCEPTION 5
+#define PyTrace_C_RETURN 6
+#define PyTrace_OPCODE 7
+
+
+typedef struct _err_stackitem {
+    /* This struct represents an entry on the exception stack, which is a
+     * per-coroutine state. (Coroutine in the computer science sense,
+     * including the thread and generators).
+     * This ensures that the exception state is not impacted by "yields"
+     * from an except handler.
+     */
+    PyObject *exc_type, *exc_value, *exc_traceback;
+
+    struct _err_stackitem *previous_item;
+
+} _PyErr_StackItem;
+
+
+// The PyThreadState typedef is in Include/pystate.h.
+struct _ts {
+    /* See Python/ceval.c for comments explaining most fields */
+
+    struct _ts *prev;
+    struct _ts *next;
+    PyInterpreterState *interp;
+
+    /* Borrowed reference to the current frame (it can be NULL) */
+    PyFrameObject *frame;
+    int recursion_depth;
+    char overflowed; /* The stack has overflowed. Allow 50 more calls
+                        to handle the runtime error. */
+    char recursion_critical; /* The current calls must not cause
+                                a stack overflow. */
+    int stackcheck_counter;
+
+    /* 'tracing' keeps track of the execution depth when tracing/profiling.
+       This is to prevent the actual trace/profile code from being recorded in
+       the trace/profile. */
+    int tracing;
+    int use_tracing;
+
+    Py_tracefunc c_profilefunc;
+    Py_tracefunc c_tracefunc;
+    PyObject *c_profileobj;
+    PyObject *c_traceobj;
+
+    /* The exception currently being raised */
+    PyObject *curexc_type;
+    PyObject *curexc_value;
+    PyObject *curexc_traceback;
+
+    /* The exception currently being handled, if no coroutines/generators
+     * are present. Always last element on the stack referred to be exc_info.
+     */
+    _PyErr_StackItem exc_state;
+
+    /* Pointer to the top of the stack of the exceptions currently
+     * being handled */
+    _PyErr_StackItem *exc_info;
+
+    PyObject *dict;  /* Stores per-thread state */
+
+    int gilstate_counter;
+
+    PyObject *async_exc; /* Asynchronous exception to raise */
+    unsigned long thread_id; /* Thread id where this tstate was created */
+
+    int trash_delete_nesting;
+    PyObject *trash_delete_later;
+
+    /* Called when a thread state is deleted normally, but not when it
+     * is destroyed after fork().
+     * Pain:  to prevent rare but fatal shutdown errors (issue 18808),
+     * Thread.join() must wait for the join'ed thread's tstate to be unlinked
+     * from the tstate chain.  That happens at the end of a thread's life,
+     * in pystate.c.
+     * The obvious way doesn't quite work:  create a lock which the tstate
+     * unlinking code releases, and have Thread.join() wait to acquire that
+     * lock.  The problem is that we _are_ at the end of the thread's life:
+     * if the thread holds the last reference to the lock, decref'ing the
+     * lock will delete the lock, and that may trigger arbitrary Python code
+     * if there's a weakref, with a callback, to the lock.  But by this time
+     * _PyRuntime.gilstate.tstate_current is already NULL, so only the simplest
+     * of C code can be allowed to run (in particular it must not be possible to
+     * release the GIL).
+     * So instead of holding the lock directly, the tstate holds a weakref to
+     * the lock:  that's the value of on_delete_data below.  Decref'ing a
+     * weakref is harmless.
+     * on_delete points to _threadmodule.c's static release_sentinel() function.
+     * After the tstate is unlinked, release_sentinel is called with the
+     * weakref-to-lock (on_delete_data) argument, and release_sentinel releases
+     * the indirectly held lock.
+     */
+    void (*on_delete)(void *);
+    void *on_delete_data;
+
+    int coroutine_origin_tracking_depth;
+
+    PyObject *async_gen_firstiter;
+    PyObject *async_gen_finalizer;
+
+    PyObject *context;
+    uint64_t context_ver;
+
+    /* Unique thread state id. */
+    uint64_t id;
+
+    /* XXX signal handlers should also be here */
+
+};
+
+// Alias for backward compatibility with Python 3.8
+#define _PyInterpreterState_Get PyInterpreterState_Get
+
+PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *);
+
+/* Similar to PyThreadState_Get(), but don't issue a fatal error
+ * if it is NULL. */
+PyAPI_FUNC(PyThreadState *) _PyThreadState_UncheckedGet(void);
+
+PyAPI_FUNC(PyObject *) _PyThreadState_GetDict(PyThreadState *tstate);
+
+/* PyGILState */
+
+/* Helper/diagnostic function - return 1 if the current thread
+   currently holds the GIL, 0 otherwise.
+
+   The function returns 1 if _PyGILState_check_enabled is non-zero. */
+PyAPI_FUNC(int) PyGILState_Check(void);
+
+/* Get the single PyInterpreterState used by this process' GILState
+   implementation.
+
+   This function doesn't check for error. Return NULL before _PyGILState_Init()
+   is called and after _PyGILState_Fini() is called.
+
+   See also _PyInterpreterState_Get() and _PyInterpreterState_GET(). */
+PyAPI_FUNC(PyInterpreterState *) _PyGILState_GetInterpreterStateUnsafe(void);
+
+/* The implementation of sys._current_frames()  Returns a dict mapping
+   thread id to that thread's current frame.
+*/
+PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void);
+
+/* Routines for advanced debuggers, requested by David Beazley.
+   Don't use unless you know what you are doing! */
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Main(void);
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void);
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *);
+PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *);
+PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *);
+PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
+
+/* Frame evaluation API */
+
+typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, PyFrameObject *, int);
+
+PyAPI_FUNC(_PyFrameEvalFunction) _PyInterpreterState_GetEvalFrameFunc(
+    PyInterpreterState *interp);
+PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc(
+    PyInterpreterState *interp,
+    _PyFrameEvalFunction eval_frame);
+
+PyAPI_FUNC(const PyConfig*) _PyInterpreterState_GetConfig(PyInterpreterState *interp);
+
+// Get the configuration of the currrent interpreter.
+// The caller must hold the GIL.
+PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void);
+
+
+/* cross-interpreter data */
+
+struct _xid;
+
+// _PyCrossInterpreterData is similar to Py_buffer as an effectively
+// opaque struct that holds data outside the object machinery.  This
+// is necessary to pass safely between interpreters in the same process.
+typedef struct _xid {
+    // data is the cross-interpreter-safe derivation of a Python object
+    // (see _PyObject_GetCrossInterpreterData).  It will be NULL if the
+    // new_object func (below) encodes the data.
+    void *data;
+    // obj is the Python object from which the data was derived.  This
+    // is non-NULL only if the data remains bound to the object in some
+    // way, such that the object must be "released" (via a decref) when
+    // the data is released.  In that case the code that sets the field,
+    // likely a registered "crossinterpdatafunc", is responsible for
+    // ensuring it owns the reference (i.e. incref).
+    PyObject *obj;
+    // interp is the ID of the owning interpreter of the original
+    // object.  It corresponds to the active interpreter when
+    // _PyObject_GetCrossInterpreterData() was called.  This should only
+    // be set by the cross-interpreter machinery.
+    //
+    // We use the ID rather than the PyInterpreterState to avoid issues
+    // with deleted interpreters.  Note that IDs are never re-used, so
+    // each one will always correspond to a specific interpreter
+    // (whether still alive or not).
+    int64_t interp;
+    // new_object is a function that returns a new object in the current
+    // interpreter given the data.  The resulting object (a new
+    // reference) will be equivalent to the original object.  This field
+    // is required.
+    PyObject *(*new_object)(struct _xid *);
+    // free is called when the data is released.  If it is NULL then
+    // nothing will be done to free the data.  For some types this is
+    // okay (e.g. bytes) and for those types this field should be set
+    // to NULL.  However, for most the data was allocated just for
+    // cross-interpreter use, so it must be freed when
+    // _PyCrossInterpreterData_Release is called or the memory will
+    // leak.  In that case, at the very least this field should be set
+    // to PyMem_RawFree (the default if not explicitly set to NULL).
+    // The call will happen with the original interpreter activated.
+    void (*free)(void *);
+} _PyCrossInterpreterData;
+
+PyAPI_FUNC(int) _PyObject_GetCrossInterpreterData(PyObject *, _PyCrossInterpreterData *);
+PyAPI_FUNC(PyObject *) _PyCrossInterpreterData_NewObject(_PyCrossInterpreterData *);
+PyAPI_FUNC(void) _PyCrossInterpreterData_Release(_PyCrossInterpreterData *);
+
+PyAPI_FUNC(int) _PyObject_CheckCrossInterpreterData(PyObject *);
+
+/* cross-interpreter data registry */
+
+typedef int (*crossinterpdatafunc)(PyObject *, struct _xid *);
+
+PyAPI_FUNC(int) _PyCrossInterpreterData_RegisterClass(PyTypeObject *, crossinterpdatafunc);
+PyAPI_FUNC(crossinterpdatafunc) _PyCrossInterpreterData_Lookup(PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/sysmodule.h b/marketing/include/cpython/sysmodule.h
new file mode 100644
index 0000000000000000000000000000000000000000..1802b5b300018e6498e0a4fdf469df0bb3a1285d
--- /dev/null
+++ b/marketing/include/cpython/sysmodule.h
@@ -0,0 +1,24 @@
+#ifndef Py_CPYTHON_SYSMODULE_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(PyObject *) _PySys_GetObjectId(_Py_Identifier *key);
+PyAPI_FUNC(int) _PySys_SetObjectId(_Py_Identifier *key, PyObject *);
+
+PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *);
+
+typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *);
+
+PyAPI_FUNC(int) PySys_Audit(
+    const char *event,
+    const char *argFormat,
+    ...);
+PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/traceback.h b/marketing/include/cpython/traceback.h
new file mode 100644
index 0000000000000000000000000000000000000000..837470c3ba2bca9491901e7d8cf14557fde27130
--- /dev/null
+++ b/marketing/include/cpython/traceback.h
@@ -0,0 +1,22 @@
+#ifndef Py_CPYTHON_TRACEBACK_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _traceback {
+    PyObject_HEAD
+    struct _traceback *tb_next;
+    PyFrameObject *tb_frame;
+    int tb_lasti;
+    int tb_lineno;
+} PyTracebackObject;
+
+PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int);
+PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/tupleobject.h b/marketing/include/cpython/tupleobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..1565f2a5c3d986ac041208e57d32e8969e48a583
--- /dev/null
+++ b/marketing/include/cpython/tupleobject.h
@@ -0,0 +1,36 @@
+#ifndef Py_CPYTHON_TUPLEOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_VAR_HEAD
+    /* ob_item contains space for 'ob_size' elements.
+       Items must normally not be NULL, except during construction when
+       the tuple is not yet visible outside the function that builds it. */
+    PyObject *ob_item[1];
+} PyTupleObject;
+
+PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t);
+PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *);
+
+/* Macros trading safety for speed */
+
+/* Cast argument to PyTupleObject* type. */
+#define _PyTuple_CAST(op) (assert(PyTuple_Check(op)), (PyTupleObject *)(op))
+
+#define PyTuple_GET_SIZE(op)    Py_SIZE(_PyTuple_CAST(op))
+
+#define PyTuple_GET_ITEM(op, i) (_PyTuple_CAST(op)->ob_item[i])
+
+/* Macro, *only* to be used to fill in brand new tuples */
+#define PyTuple_SET_ITEM(op, i, v) (_PyTuple_CAST(op)->ob_item[i] = v)
+
+PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/cpython/unicodeobject.h b/marketing/include/cpython/unicodeobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee41cfa72294f61b1dbb7179582cab0e10534d6e
--- /dev/null
+++ b/marketing/include/cpython/unicodeobject.h
@@ -0,0 +1,1254 @@
+#ifndef Py_CPYTHON_UNICODEOBJECT_H
+#  error "this header file must not be included directly"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Py_UNICODE was the native Unicode storage format (code unit) used by
+   Python and represents a single Unicode element in the Unicode type.
+   With PEP 393, Py_UNICODE is deprecated and replaced with a
+   typedef to wchar_t. */
+#define PY_UNICODE_TYPE wchar_t
+/* Py_DEPRECATED(3.3) */ typedef wchar_t Py_UNICODE;
+
+/* --- Internal Unicode Operations ---------------------------------------- */
+
+/* Since splitting on whitespace is an important use case, and
+   whitespace in most situations is solely ASCII whitespace, we
+   optimize for the common case by using a quick look-up table
+   _Py_ascii_whitespace (see below) with an inlined check.
+
+ */
+#define Py_UNICODE_ISSPACE(ch) \
+    ((Py_UCS4)(ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch))
+
+#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch)
+#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch)
+#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch)
+#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch)
+
+#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch)
+#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch)
+#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch)
+
+#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch)
+#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch)
+#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch)
+#define Py_UNICODE_ISPRINTABLE(ch) _PyUnicode_IsPrintable(ch)
+
+#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch)
+#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch)
+#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch)
+
+#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch)
+
+#define Py_UNICODE_ISALNUM(ch) \
+       (Py_UNICODE_ISALPHA(ch) || \
+    Py_UNICODE_ISDECIMAL(ch) || \
+    Py_UNICODE_ISDIGIT(ch) || \
+    Py_UNICODE_ISNUMERIC(ch))
+
+Py_DEPRECATED(3.3) static inline void
+Py_UNICODE_COPY(Py_UNICODE *target, const Py_UNICODE *source, Py_ssize_t length) {
+    memcpy(target, source, (size_t)(length) * sizeof(Py_UNICODE));
+}
+
+Py_DEPRECATED(3.3) static inline void
+Py_UNICODE_FILL(Py_UNICODE *target, Py_UNICODE value, Py_ssize_t length) {
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        target[i] = value;
+    }
+}
+
+/* macros to work with surrogates */
+#define Py_UNICODE_IS_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDFFF)
+#define Py_UNICODE_IS_HIGH_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDBFF)
+#define Py_UNICODE_IS_LOW_SURROGATE(ch) (0xDC00 <= (ch) && (ch) <= 0xDFFF)
+/* Join two surrogate characters and return a single Py_UCS4 value. */
+#define Py_UNICODE_JOIN_SURROGATES(high, low)  \
+    (((((Py_UCS4)(high) & 0x03FF) << 10) |      \
+      ((Py_UCS4)(low) & 0x03FF)) + 0x10000)
+/* high surrogate = top 10 bits added to D800 */
+#define Py_UNICODE_HIGH_SURROGATE(ch) (0xD800 - (0x10000 >> 10) + ((ch) >> 10))
+/* low surrogate = bottom 10 bits added to DC00 */
+#define Py_UNICODE_LOW_SURROGATE(ch) (0xDC00 + ((ch) & 0x3FF))
+
+/* --- Unicode Type ------------------------------------------------------- */
+
+/* ASCII-only strings created through PyUnicode_New use the PyASCIIObject
+   structure. state.ascii and state.compact are set, and the data
+   immediately follow the structure. utf8_length and wstr_length can be found
+   in the length field; the utf8 pointer is equal to the data pointer. */
+typedef struct {
+    /* There are 4 forms of Unicode strings:
+
+       - compact ascii:
+
+         * structure = PyASCIIObject
+         * test: PyUnicode_IS_COMPACT_ASCII(op)
+         * kind = PyUnicode_1BYTE_KIND
+         * compact = 1
+         * ascii = 1
+         * ready = 1
+         * (length is the length of the utf8 and wstr strings)
+         * (data starts just after the structure)
+         * (since ASCII is decoded from UTF-8, the utf8 string are the data)
+
+       - compact:
+
+         * structure = PyCompactUnicodeObject
+         * test: PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op)
+         * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
+           PyUnicode_4BYTE_KIND
+         * compact = 1
+         * ready = 1
+         * ascii = 0
+         * utf8 is not shared with data
+         * utf8_length = 0 if utf8 is NULL
+         * wstr is shared with data and wstr_length=length
+           if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2
+           or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_t)=4
+         * wstr_length = 0 if wstr is NULL
+         * (data starts just after the structure)
+
+       - legacy string, not ready:
+
+         * structure = PyUnicodeObject
+         * test: kind == PyUnicode_WCHAR_KIND
+         * length = 0 (use wstr_length)
+         * hash = -1
+         * kind = PyUnicode_WCHAR_KIND
+         * compact = 0
+         * ascii = 0
+         * ready = 0
+         * interned = SSTATE_NOT_INTERNED
+         * wstr is not NULL
+         * data.any is NULL
+         * utf8 is NULL
+         * utf8_length = 0
+
+       - legacy string, ready:
+
+         * structure = PyUnicodeObject structure
+         * test: !PyUnicode_IS_COMPACT(op) && kind != PyUnicode_WCHAR_KIND
+         * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
+           PyUnicode_4BYTE_KIND
+         * compact = 0
+         * ready = 1
+         * data.any is not NULL
+         * utf8 is shared and utf8_length = length with data.any if ascii = 1
+         * utf8_length = 0 if utf8 is NULL
+         * wstr is shared with data.any and wstr_length = length
+           if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2
+           or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_4)=4
+         * wstr_length = 0 if wstr is NULL
+
+       Compact strings use only one memory block (structure + characters),
+       whereas legacy strings use one block for the structure and one block
+       for characters.
+
+       Legacy strings are created by PyUnicode_FromUnicode() and
+       PyUnicode_FromStringAndSize(NULL, size) functions. They become ready
+       when PyUnicode_READY() is called.
+
+       See also _PyUnicode_CheckConsistency().
+    */
+    PyObject_HEAD
+    Py_ssize_t length;          /* Number of code points in the string */
+    Py_hash_t hash;             /* Hash value; -1 if not set */
+    struct {
+        /*
+           SSTATE_NOT_INTERNED (0)
+           SSTATE_INTERNED_MORTAL (1)
+           SSTATE_INTERNED_IMMORTAL (2)
+
+           If interned != SSTATE_NOT_INTERNED, the two references from the
+           dictionary to this object are *not* counted in ob_refcnt.
+         */
+        unsigned int interned:2;
+        /* Character size:
+
+           - PyUnicode_WCHAR_KIND (0):
+
+             * character type = wchar_t (16 or 32 bits, depending on the
+               platform)
+
+           - PyUnicode_1BYTE_KIND (1):
+
+             * character type = Py_UCS1 (8 bits, unsigned)
+             * all characters are in the range U+0000-U+00FF (latin1)
+             * if ascii is set, all characters are in the range U+0000-U+007F
+               (ASCII), otherwise at least one character is in the range
+               U+0080-U+00FF
+
+           - PyUnicode_2BYTE_KIND (2):
+
+             * character type = Py_UCS2 (16 bits, unsigned)
+             * all characters are in the range U+0000-U+FFFF (BMP)
+             * at least one character is in the range U+0100-U+FFFF
+
+           - PyUnicode_4BYTE_KIND (4):
+
+             * character type = Py_UCS4 (32 bits, unsigned)
+             * all characters are in the range U+0000-U+10FFFF
+             * at least one character is in the range U+10000-U+10FFFF
+         */
+        unsigned int kind:3;
+        /* Compact is with respect to the allocation scheme. Compact unicode
+           objects only require one memory block while non-compact objects use
+           one block for the PyUnicodeObject struct and another for its data
+           buffer. */
+        unsigned int compact:1;
+        /* The string only contains characters in the range U+0000-U+007F (ASCII)
+           and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is
+           set, use the PyASCIIObject structure. */
+        unsigned int ascii:1;
+        /* The ready flag indicates whether the object layout is initialized
+           completely. This means that this is either a compact object, or
+           the data pointer is filled out. The bit is redundant, and helps
+           to minimize the test in PyUnicode_IS_READY(). */
+        unsigned int ready:1;
+        /* Padding to ensure that PyUnicode_DATA() is always aligned to
+           4 bytes (see issue #19537 on m68k). */
+        unsigned int :24;
+    } state;
+    wchar_t *wstr;              /* wchar_t representation (null-terminated) */
+} PyASCIIObject;
+
+/* Non-ASCII strings allocated through PyUnicode_New use the
+   PyCompactUnicodeObject structure. state.compact is set, and the data
+   immediately follow the structure. */
+typedef struct {
+    PyASCIIObject _base;
+    Py_ssize_t utf8_length;     /* Number of bytes in utf8, excluding the
+                                 * terminating \0. */
+    char *utf8;                 /* UTF-8 representation (null-terminated) */
+    Py_ssize_t wstr_length;     /* Number of code points in wstr, possible
+                                 * surrogates count as two code points. */
+} PyCompactUnicodeObject;
+
+/* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the
+   PyUnicodeObject structure. The actual string data is initially in the wstr
+   block, and copied into the data block using _PyUnicode_Ready. */
+typedef struct {
+    PyCompactUnicodeObject _base;
+    union {
+        void *any;
+        Py_UCS1 *latin1;
+        Py_UCS2 *ucs2;
+        Py_UCS4 *ucs4;
+    } data;                     /* Canonical, smallest-form Unicode buffer */
+} PyUnicodeObject;
+
+PyAPI_FUNC(int) _PyUnicode_CheckConsistency(
+    PyObject *op,
+    int check_content);
+
+/* Fast access macros */
+
+/* Returns the deprecated Py_UNICODE representation's size in code units
+   (this includes surrogate pairs as 2 units).
+   If the Py_UNICODE representation is not available, it will be computed
+   on request.  Use PyUnicode_GET_LENGTH() for the length in code points. */
+
+/* Py_DEPRECATED(3.3) */
+#define PyUnicode_GET_SIZE(op)                       \
+    (assert(PyUnicode_Check(op)),                    \
+     (((PyASCIIObject *)(op))->wstr) ?               \
+      PyUnicode_WSTR_LENGTH(op) :                    \
+      ((void)PyUnicode_AsUnicode(_PyObject_CAST(op)),\
+       assert(((PyASCIIObject *)(op))->wstr),        \
+       PyUnicode_WSTR_LENGTH(op)))
+
+/* Py_DEPRECATED(3.3) */
+#define PyUnicode_GET_DATA_SIZE(op) \
+    (PyUnicode_GET_SIZE(op) * Py_UNICODE_SIZE)
+
+/* Alias for PyUnicode_AsUnicode().  This will create a wchar_t/Py_UNICODE
+   representation on demand.  Using this macro is very inefficient now,
+   try to port your code to use the new PyUnicode_*BYTE_DATA() macros or
+   use PyUnicode_WRITE() and PyUnicode_READ(). */
+
+/* Py_DEPRECATED(3.3) */
+#define PyUnicode_AS_UNICODE(op) \
+    (assert(PyUnicode_Check(op)), \
+     (((PyASCIIObject *)(op))->wstr) ? (((PyASCIIObject *)(op))->wstr) : \
+      PyUnicode_AsUnicode(_PyObject_CAST(op)))
+
+/* Py_DEPRECATED(3.3) */
+#define PyUnicode_AS_DATA(op) \
+    ((const char *)(PyUnicode_AS_UNICODE(op)))
+
+
+/* --- Flexible String Representation Helper Macros (PEP 393) -------------- */
+
+/* Values for PyASCIIObject.state: */
+
+/* Interning state. */
+#define SSTATE_NOT_INTERNED 0
+#define SSTATE_INTERNED_MORTAL 1
+#define SSTATE_INTERNED_IMMORTAL 2
+
+/* Return true if the string contains only ASCII characters, or 0 if not. The
+   string may be compact (PyUnicode_IS_COMPACT_ASCII) or not, but must be
+   ready. */
+#define PyUnicode_IS_ASCII(op)                   \
+    (assert(PyUnicode_Check(op)),                \
+     assert(PyUnicode_IS_READY(op)),             \
+     ((PyASCIIObject*)op)->state.ascii)
+
+/* Return true if the string is compact or 0 if not.
+   No type checks or Ready calls are performed. */
+#define PyUnicode_IS_COMPACT(op) \
+    (((PyASCIIObject*)(op))->state.compact)
+
+/* Return true if the string is a compact ASCII string (use PyASCIIObject
+   structure), or 0 if not.  No type checks or Ready calls are performed. */
+#define PyUnicode_IS_COMPACT_ASCII(op)                 \
+    (((PyASCIIObject*)op)->state.ascii && PyUnicode_IS_COMPACT(op))
+
+enum PyUnicode_Kind {
+/* String contains only wstr byte characters.  This is only possible
+   when the string was created with a legacy API and _PyUnicode_Ready()
+   has not been called yet.  */
+    PyUnicode_WCHAR_KIND = 0,
+/* Return values of the PyUnicode_KIND() macro: */
+    PyUnicode_1BYTE_KIND = 1,
+    PyUnicode_2BYTE_KIND = 2,
+    PyUnicode_4BYTE_KIND = 4
+};
+
+/* Return pointers to the canonical representation cast to unsigned char,
+   Py_UCS2, or Py_UCS4 for direct character access.
+   No checks are performed, use PyUnicode_KIND() before to ensure
+   these will work correctly. */
+
+#define PyUnicode_1BYTE_DATA(op) ((Py_UCS1*)PyUnicode_DATA(op))
+#define PyUnicode_2BYTE_DATA(op) ((Py_UCS2*)PyUnicode_DATA(op))
+#define PyUnicode_4BYTE_DATA(op) ((Py_UCS4*)PyUnicode_DATA(op))
+
+/* Return one of the PyUnicode_*_KIND values defined above. */
+#define PyUnicode_KIND(op) \
+    (assert(PyUnicode_Check(op)), \
+     assert(PyUnicode_IS_READY(op)),            \
+     ((PyASCIIObject *)(op))->state.kind)
+
+/* Return a void pointer to the raw unicode buffer. */
+#define _PyUnicode_COMPACT_DATA(op)                     \
+    (PyUnicode_IS_ASCII(op) ?                   \
+     ((void*)((PyASCIIObject*)(op) + 1)) :              \
+     ((void*)((PyCompactUnicodeObject*)(op) + 1)))
+
+#define _PyUnicode_NONCOMPACT_DATA(op)                  \
+    (assert(((PyUnicodeObject*)(op))->data.any),        \
+     ((((PyUnicodeObject *)(op))->data.any)))
+
+#define PyUnicode_DATA(op) \
+    (assert(PyUnicode_Check(op)), \
+     PyUnicode_IS_COMPACT(op) ? _PyUnicode_COMPACT_DATA(op) :   \
+     _PyUnicode_NONCOMPACT_DATA(op))
+
+/* In the access macros below, "kind" may be evaluated more than once.
+   All other macro parameters are evaluated exactly once, so it is safe
+   to put side effects into them (such as increasing the index). */
+
+/* Write into the canonical representation, this macro does not do any sanity
+   checks and is intended for usage in loops.  The caller should cache the
+   kind and data pointers obtained from other macro calls.
+   index is the index in the string (starts at 0) and value is the new
+   code point value which should be written to that location. */
+#define PyUnicode_WRITE(kind, data, index, value) \
+    do { \
+        switch ((kind)) { \
+        case PyUnicode_1BYTE_KIND: { \
+            ((Py_UCS1 *)(data))[(index)] = (Py_UCS1)(value); \
+            break; \
+        } \
+        case PyUnicode_2BYTE_KIND: { \
+            ((Py_UCS2 *)(data))[(index)] = (Py_UCS2)(value); \
+            break; \
+        } \
+        default: { \
+            assert((kind) == PyUnicode_4BYTE_KIND); \
+            ((Py_UCS4 *)(data))[(index)] = (Py_UCS4)(value); \
+        } \
+        } \
+    } while (0)
+
+/* Read a code point from the string's canonical representation.  No checks
+   or ready calls are performed. */
+#define PyUnicode_READ(kind, data, index) \
+    ((Py_UCS4) \
+    ((kind) == PyUnicode_1BYTE_KIND ? \
+        ((const Py_UCS1 *)(data))[(index)] : \
+        ((kind) == PyUnicode_2BYTE_KIND ? \
+            ((const Py_UCS2 *)(data))[(index)] : \
+            ((const Py_UCS4 *)(data))[(index)] \
+        ) \
+    ))
+
+/* PyUnicode_READ_CHAR() is less efficient than PyUnicode_READ() because it
+   calls PyUnicode_KIND() and might call it twice.  For single reads, use
+   PyUnicode_READ_CHAR, for multiple consecutive reads callers should
+   cache kind and use PyUnicode_READ instead. */
+#define PyUnicode_READ_CHAR(unicode, index) \
+    (assert(PyUnicode_Check(unicode)),          \
+     assert(PyUnicode_IS_READY(unicode)),       \
+     (Py_UCS4)                                  \
+        (PyUnicode_KIND((unicode)) == PyUnicode_1BYTE_KIND ? \
+            ((const Py_UCS1 *)(PyUnicode_DATA((unicode))))[(index)] : \
+            (PyUnicode_KIND((unicode)) == PyUnicode_2BYTE_KIND ? \
+                ((const Py_UCS2 *)(PyUnicode_DATA((unicode))))[(index)] : \
+                ((const Py_UCS4 *)(PyUnicode_DATA((unicode))))[(index)] \
+            ) \
+        ))
+
+/* Returns the length of the unicode string. The caller has to make sure that
+   the string has it's canonical representation set before calling
+   this macro.  Call PyUnicode_(FAST_)Ready to ensure that. */
+#define PyUnicode_GET_LENGTH(op)                \
+    (assert(PyUnicode_Check(op)),               \
+     assert(PyUnicode_IS_READY(op)),            \
+     ((PyASCIIObject *)(op))->length)
+
+
+/* Fast check to determine whether an object is ready. Equivalent to
+   PyUnicode_IS_COMPACT(op) || ((PyUnicodeObject*)(op))->data.any */
+
+#define PyUnicode_IS_READY(op) (((PyASCIIObject*)op)->state.ready)
+
+/* PyUnicode_READY() does less work than _PyUnicode_Ready() in the best
+   case.  If the canonical representation is not yet set, it will still call
+   _PyUnicode_Ready().
+   Returns 0 on success and -1 on errors. */
+#define PyUnicode_READY(op)                        \
+    (assert(PyUnicode_Check(op)),                       \
+     (PyUnicode_IS_READY(op) ?                          \
+      0 : _PyUnicode_Ready(_PyObject_CAST(op))))
+
+/* Return a maximum character value which is suitable for creating another
+   string based on op.  This is always an approximation but more efficient
+   than iterating over the string. */
+#define PyUnicode_MAX_CHAR_VALUE(op) \
+    (assert(PyUnicode_IS_READY(op)),                                    \
+     (PyUnicode_IS_ASCII(op) ?                                          \
+      (0x7f) :                                                          \
+      (PyUnicode_KIND(op) == PyUnicode_1BYTE_KIND ?                     \
+       (0xffU) :                                                        \
+       (PyUnicode_KIND(op) == PyUnicode_2BYTE_KIND ?                    \
+        (0xffffU) :                                                     \
+        (0x10ffffU)))))
+
+Py_DEPRECATED(3.3)
+static inline Py_ssize_t _PyUnicode_get_wstr_length(PyObject *op) {
+    return PyUnicode_IS_COMPACT_ASCII(op) ?
+            ((PyASCIIObject*)op)->length :
+            ((PyCompactUnicodeObject*)op)->wstr_length;
+}
+#define PyUnicode_WSTR_LENGTH(op) _PyUnicode_get_wstr_length((PyObject*)op)
+
+/* === Public API ========================================================= */
+
+/* --- Plain Py_UNICODE --------------------------------------------------- */
+
+/* With PEP 393, this is the recommended way to allocate a new unicode object.
+   This function will allocate the object and its buffer in a single memory
+   block.  Objects created using this function are not resizable. */
+PyAPI_FUNC(PyObject*) PyUnicode_New(
+    Py_ssize_t size,            /* Number of code points in the new string */
+    Py_UCS4 maxchar             /* maximum code point value in the string */
+    );
+
+/* Initializes the canonical string representation from the deprecated
+   wstr/Py_UNICODE representation. This function is used to convert Unicode
+   objects which were created using the old API to the new flexible format
+   introduced with PEP 393.
+
+   Don't call this function directly, use the public PyUnicode_READY() macro
+   instead. */
+PyAPI_FUNC(int) _PyUnicode_Ready(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* Get a copy of a Unicode string. */
+PyAPI_FUNC(PyObject*) _PyUnicode_Copy(
+    PyObject *unicode
+    );
+
+/* Copy character from one unicode object into another, this function performs
+   character conversion when necessary and falls back to memcpy() if possible.
+
+   Fail if to is too small (smaller than *how_many* or smaller than
+   len(from)-from_start), or if kind(from[from_start:from_start+how_many]) >
+   kind(to), or if *to* has more than 1 reference.
+
+   Return the number of written character, or return -1 and raise an exception
+   on error.
+
+   Pseudo-code:
+
+       how_many = min(how_many, len(from) - from_start)
+       to[to_start:to_start+how_many] = from[from_start:from_start+how_many]
+       return how_many
+
+   Note: The function doesn't write a terminating null character.
+   */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters(
+    PyObject *to,
+    Py_ssize_t to_start,
+    PyObject *from,
+    Py_ssize_t from_start,
+    Py_ssize_t how_many
+    );
+
+/* Unsafe version of PyUnicode_CopyCharacters(): don't check arguments and so
+   may crash if parameters are invalid (e.g. if the output string
+   is too short). */
+PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters(
+    PyObject *to,
+    Py_ssize_t to_start,
+    PyObject *from,
+    Py_ssize_t from_start,
+    Py_ssize_t how_many
+    );
+
+/* Fill a string with a character: write fill_char into
+   unicode[start:start+length].
+
+   Fail if fill_char is bigger than the string maximum character, or if the
+   string has more than 1 reference.
+
+   Return the number of written character, or return -1 and raise an exception
+   on error. */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill(
+    PyObject *unicode,
+    Py_ssize_t start,
+    Py_ssize_t length,
+    Py_UCS4 fill_char
+    );
+
+/* Unsafe version of PyUnicode_Fill(): don't check arguments and so may crash
+   if parameters are invalid (e.g. if length is longer than the string). */
+PyAPI_FUNC(void) _PyUnicode_FastFill(
+    PyObject *unicode,
+    Py_ssize_t start,
+    Py_ssize_t length,
+    Py_UCS4 fill_char
+    );
+
+/* Create a Unicode Object from the Py_UNICODE buffer u of the given
+   size.
+
+   u may be NULL which causes the contents to be undefined. It is the
+   user's responsibility to fill in the needed data afterwards. Note
+   that modifying the Unicode object contents after construction is
+   only allowed if u was set to NULL.
+
+   The buffer is copied into the new object. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode(
+    const Py_UNICODE *u,        /* Unicode buffer */
+    Py_ssize_t size             /* size of buffer */
+    );
+
+/* Create a new string from a buffer of Py_UCS1, Py_UCS2 or Py_UCS4 characters.
+   Scan the string to find the maximum character. */
+PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData(
+    int kind,
+    const void *buffer,
+    Py_ssize_t size);
+
+/* Create a new string from a buffer of ASCII characters.
+   WARNING: Don't check if the string contains any non-ASCII character. */
+PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII(
+    const char *buffer,
+    Py_ssize_t size);
+
+/* Compute the maximum character of the substring unicode[start:end].
+   Return 127 for an empty string. */
+PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar (
+    PyObject *unicode,
+    Py_ssize_t start,
+    Py_ssize_t end);
+
+/* Return a read-only pointer to the Unicode object's internal
+   Py_UNICODE buffer.
+   If the wchar_t/Py_UNICODE representation is not yet available, this
+   function will calculate it. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* Similar to PyUnicode_AsUnicode(), but raises a ValueError if the string
+   contains null characters. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(const Py_UNICODE *) _PyUnicode_AsUnicode(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* Return a read-only pointer to the Unicode object's internal
+   Py_UNICODE buffer and save the length at size.
+   If the wchar_t/Py_UNICODE representation is not yet available, this
+   function will calculate it. */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize(
+    PyObject *unicode,          /* Unicode object */
+    Py_ssize_t *size            /* location where to save the length */
+    );
+
+/* Get the maximum ordinal for a Unicode character. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void);
+
+
+/* --- _PyUnicodeWriter API ----------------------------------------------- */
+
+typedef struct {
+    PyObject *buffer;
+    void *data;
+    enum PyUnicode_Kind kind;
+    Py_UCS4 maxchar;
+    Py_ssize_t size;
+    Py_ssize_t pos;
+
+    /* minimum number of allocated characters (default: 0) */
+    Py_ssize_t min_length;
+
+    /* minimum character (default: 127, ASCII) */
+    Py_UCS4 min_char;
+
+    /* If non-zero, overallocate the buffer (default: 0). */
+    unsigned char overallocate;
+
+    /* If readonly is 1, buffer is a shared string (cannot be modified)
+       and size is set to 0. */
+    unsigned char readonly;
+} _PyUnicodeWriter ;
+
+/* Initialize a Unicode writer.
+ *
+ * By default, the minimum buffer size is 0 character and overallocation is
+ * disabled. Set min_length, min_char and overallocate attributes to control
+ * the allocation of the buffer. */
+PyAPI_FUNC(void)
+_PyUnicodeWriter_Init(_PyUnicodeWriter *writer);
+
+/* Prepare the buffer to write 'length' characters
+   with the specified maximum character.
+
+   Return 0 on success, raise an exception and return -1 on error. */
+#define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR)             \
+    (((MAXCHAR) <= (WRITER)->maxchar                                  \
+      && (LENGTH) <= (WRITER)->size - (WRITER)->pos)                  \
+     ? 0                                                              \
+     : (((LENGTH) == 0)                                               \
+        ? 0                                                           \
+        : _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR))))
+
+/* Don't call this function directly, use the _PyUnicodeWriter_Prepare() macro
+   instead. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer,
+                                 Py_ssize_t length, Py_UCS4 maxchar);
+
+/* Prepare the buffer to have at least the kind KIND.
+   For example, kind=PyUnicode_2BYTE_KIND ensures that the writer will
+   support characters in range U+000-U+FFFF.
+
+   Return 0 on success, raise an exception and return -1 on error. */
+#define _PyUnicodeWriter_PrepareKind(WRITER, KIND)                    \
+    (assert((KIND) != PyUnicode_WCHAR_KIND),                          \
+     (KIND) <= (WRITER)->kind                                         \
+     ? 0                                                              \
+     : _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND)))
+
+/* Don't call this function directly, use the _PyUnicodeWriter_PrepareKind()
+   macro instead. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer,
+                                     enum PyUnicode_Kind kind);
+
+/* Append a Unicode character.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer,
+    Py_UCS4 ch
+    );
+
+/* Append a Unicode string.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer,
+    PyObject *str               /* Unicode string */
+    );
+
+/* Append a substring of a Unicode string.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer,
+    PyObject *str,              /* Unicode string */
+    Py_ssize_t start,
+    Py_ssize_t end
+    );
+
+/* Append an ASCII-encoded byte string.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer,
+    const char *str,           /* ASCII-encoded byte string */
+    Py_ssize_t len             /* number of bytes, or -1 if unknown */
+    );
+
+/* Append a latin1-encoded byte string.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int)
+_PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer,
+    const char *str,           /* latin1-encoded byte string */
+    Py_ssize_t len             /* length in bytes */
+    );
+
+/* Get the value of the writer as a Unicode string. Clear the
+   buffer of the writer. Raise an exception and return NULL
+   on error. */
+PyAPI_FUNC(PyObject *)
+_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer);
+
+/* Deallocate memory of a writer (clear its internal buffer). */
+PyAPI_FUNC(void)
+_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer);
+
+
+/* Format the object based on the format_spec, as defined in PEP 3101
+   (Advanced String Formatting). */
+PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter(
+    _PyUnicodeWriter *writer,
+    PyObject *obj,
+    PyObject *format_spec,
+    Py_ssize_t start,
+    Py_ssize_t end);
+
+/* --- Manage the default encoding ---------------------------------------- */
+
+/* Returns a pointer to the default encoding (UTF-8) of the
+   Unicode object unicode and the size of the encoded representation
+   in bytes stored in *size.
+
+   In case of an error, no *size is set.
+
+   This function caches the UTF-8 encoded string in the unicodeobject
+   and subsequent calls will return the same string.  The memory is released
+   when the unicodeobject is deallocated.
+
+   _PyUnicode_AsStringAndSize is a #define for PyUnicode_AsUTF8AndSize to
+   support the previous internal function with the same behaviour.
+*/
+
+PyAPI_FUNC(const char *) PyUnicode_AsUTF8AndSize(
+    PyObject *unicode,
+    Py_ssize_t *size);
+
+#define _PyUnicode_AsStringAndSize PyUnicode_AsUTF8AndSize
+
+/* Returns a pointer to the default encoding (UTF-8) of the
+   Unicode object unicode.
+
+   Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation
+   in the unicodeobject.
+
+   _PyUnicode_AsString is a #define for PyUnicode_AsUTF8 to
+   support the previous internal function with the same behaviour.
+
+   Use of this API is DEPRECATED since no size information can be
+   extracted from the returned data.
+*/
+
+PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode);
+
+#define _PyUnicode_AsString PyUnicode_AsUTF8
+
+/* --- Generic Codecs ----------------------------------------------------- */
+
+/* Encodes a Py_UNICODE buffer of the given size and returns a
+   Python string object. */
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_Encode(
+    const Py_UNICODE *s,        /* Unicode char buffer */
+    Py_ssize_t size,            /* number of Py_UNICODE chars to encode */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
+    );
+
+/* --- UTF-7 Codecs ------------------------------------------------------- */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    int base64SetO,             /* Encode RFC2152 Set O characters in base64 */
+    int base64WhiteSpace,       /* Encode whitespace (sp, ht, nl, cr) in base64 */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7(
+    PyObject *unicode,          /* Unicode object */
+    int base64SetO,             /* Encode RFC2152 Set O characters in base64 */
+    int base64WhiteSpace,       /* Encode whitespace (sp, ht, nl, cr) in base64 */
+    const char *errors          /* error handling */
+    );
+
+/* --- UTF-8 Codecs ------------------------------------------------------- */
+
+PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String(
+    PyObject *unicode,
+    const char *errors);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+
+/* --- UTF-32 Codecs ------------------------------------------------------ */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32(
+    PyObject *object,           /* Unicode object */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    );
+
+/* --- UTF-16 Codecs ------------------------------------------------------ */
+
+/* Returns a Python string object holding the UTF-16 encoded value of
+   the Unicode data.
+
+   If byteorder is not 0, output is written according to the following
+   byte order:
+
+   byteorder == -1: little endian
+   byteorder == 0:  native byte order (writes a BOM mark)
+   byteorder == 1:  big endian
+
+   If byteorder is 0, the output string will always start with the
+   Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
+   prepended.
+
+   Note that Py_UNICODE data is being interpreted as UTF-16 reduced to
+   UCS-2. This trick makes it possible to add full UTF-16 capabilities
+   at a later point without compromising the APIs.
+
+*/
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16(
+    PyObject* unicode,          /* Unicode object */
+    const char *errors,         /* error handling */
+    int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+    );
+
+/* --- Unicode-Escape Codecs ---------------------------------------------- */
+
+/* Variant of PyUnicode_DecodeUnicodeEscape that supports partial decoding. */
+PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeStateful(
+        const char *string,     /* Unicode-Escape encoded string */
+        Py_ssize_t length,      /* size of string */
+        const char *errors,     /* error handling */
+        Py_ssize_t *consumed    /* bytes consumed */
+);
+/* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape
+   chars. */
+PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal(
+        const char *string,     /* Unicode-Escape encoded string */
+        Py_ssize_t length,      /* size of string */
+        const char *errors,     /* error handling */
+        Py_ssize_t *consumed,   /* bytes consumed */
+        const char **first_invalid_escape  /* on return, points to first
+                                              invalid escaped char in
+                                              string. */
+);
+
+/*
+ * START Anaconda (tkoch):
+ *
+ * For compatibility with packages like typed_ast and mypy compiled against
+ * Python 3.9.7.
+ */
+PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscape(
+        const char *string,     /* Unicode-Escape encoded string */
+        Py_ssize_t length,      /* size of string */
+        const char *errors,     /* error handling */
+        const char **first_invalid_escape  /* on return, points to first
+                                              invalid escaped char in
+                                              string. */
+);
+
+/* Anaconda END */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length           /* Number of Py_UNICODE chars to encode */
+    );
+
+/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length           /* Number of Py_UNICODE chars to encode */
+    );
+
+/* Variant of PyUnicode_DecodeRawUnicodeEscape that supports partial decoding. */
+PyAPI_FUNC(PyObject*) _PyUnicode_DecodeRawUnicodeEscapeStateful(
+        const char *string,     /* Unicode-Escape encoded string */
+        Py_ssize_t length,      /* size of string */
+        const char *errors,     /* error handling */
+        Py_ssize_t *consumed    /* bytes consumed */
+);
+
+/* --- Latin-1 Codecs ----------------------------------------------------- */
+
+PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String(
+    PyObject* unicode,
+    const char* errors);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+
+/* --- ASCII Codecs ------------------------------------------------------- */
+
+PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString(
+    PyObject* unicode,
+    const char* errors);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+
+/* --- Character Map Codecs ----------------------------------------------- */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    PyObject *mapping,          /* encoding mapping */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap(
+    PyObject *unicode,          /* Unicode object */
+    PyObject *mapping,          /* encoding mapping */
+    const char *errors          /* error handling */
+    );
+
+/* Translate a Py_UNICODE buffer of the given length by applying a
+   character mapping table to it and return the resulting Unicode
+   object.
+
+   The mapping table must map Unicode ordinal integers to Unicode strings,
+   Unicode ordinal integers or None (causing deletion of the character).
+
+   Mapping tables may be dictionaries or sequences. Unmapped character
+   ordinals (ones which cause a LookupError) are left untouched and
+   are copied as-is.
+
+*/
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    PyObject *table,            /* Translate table */
+    const char *errors          /* error handling */
+    );
+
+/* --- MBCS codecs for Windows -------------------------------------------- */
+
+#ifdef MS_WINDOWS
+Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
+    const Py_UNICODE *data,     /* Unicode char buffer */
+    Py_ssize_t length,          /* number of Py_UNICODE chars to encode */
+    const char *errors          /* error handling */
+    );
+#endif
+
+/* --- Decimal Encoder ---------------------------------------------------- */
+
+/* Takes a Unicode string holding a decimal value and writes it into
+   an output buffer using standard ASCII digit codes.
+
+   The output buffer has to provide at least length+1 bytes of storage
+   area. The output string is 0-terminated.
+
+   The encoder converts whitespace to ' ', decimal characters to their
+   corresponding ASCII digit and all other Latin-1 characters except
+   \0 as-is. Characters outside this range (Unicode ordinals 1-256)
+   are treated as errors. This includes embedded NULL bytes.
+
+   Error handling is defined by the errors argument:
+
+      NULL or "strict": raise a ValueError
+      "ignore": ignore the wrong characters (these are not copied to the
+                output buffer)
+      "replace": replaces illegal characters with '?'
+
+   Returns 0 on success, -1 on failure.
+
+*/
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(int) PyUnicode_EncodeDecimal(
+    Py_UNICODE *s,              /* Unicode buffer */
+    Py_ssize_t length,          /* Number of Py_UNICODE chars to encode */
+    char *output,               /* Output buffer; must have size >= length */
+    const char *errors          /* error handling */
+    );
+
+/* Transforms code points that have decimal digit property to the
+   corresponding ASCII digit code points.
+
+   Returns a new Unicode string on success, NULL on failure.
+*/
+
+Py_DEPRECATED(3.3)
+PyAPI_FUNC(PyObject*) PyUnicode_TransformDecimalToASCII(
+    Py_UNICODE *s,              /* Unicode buffer */
+    Py_ssize_t length           /* Number of Py_UNICODE chars to transform */
+    );
+
+/* Coverts a Unicode object holding a decimal value to an ASCII string
+   for using in int, float and complex parsers.
+   Transforms code points that have decimal digit property to the
+   corresponding ASCII digit code points.  Transforms spaces to ASCII.
+   Transforms code points starting from the first non-ASCII code point that
+   is neither a decimal digit nor a space to the end into '?'. */
+
+PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* --- Methods & Slots ---------------------------------------------------- */
+
+PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray(
+    PyObject *separator,
+    PyObject *const *items,
+    Py_ssize_t seqlen
+    );
+
+/* Test whether a unicode is equal to ASCII identifier.  Return 1 if true,
+   0 otherwise.  The right argument must be ASCII identifier.
+   Any error occurs inside will be cleared before return. */
+PyAPI_FUNC(int) _PyUnicode_EqualToASCIIId(
+    PyObject *left,             /* Left string */
+    _Py_Identifier *right       /* Right identifier */
+    );
+
+/* Test whether a unicode is equal to ASCII string.  Return 1 if true,
+   0 otherwise.  The right argument must be ASCII-encoded string.
+   Any error occurs inside will be cleared before return. */
+PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString(
+    PyObject *left,
+    const char *right           /* ASCII-encoded string */
+    );
+
+/* Externally visible for str.strip(unicode) */
+PyAPI_FUNC(PyObject *) _PyUnicode_XStrip(
+    PyObject *self,
+    int striptype,
+    PyObject *sepobj
+    );
+
+/* Using explicit passed-in values, insert the thousands grouping
+   into the string pointed to by buffer.  For the argument descriptions,
+   see Objects/stringlib/localeutil.h */
+PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping(
+    _PyUnicodeWriter *writer,
+    Py_ssize_t n_buffer,
+    PyObject *digits,
+    Py_ssize_t d_pos,
+    Py_ssize_t n_digits,
+    Py_ssize_t min_width,
+    const char *grouping,
+    PyObject *thousands_sep,
+    Py_UCS4 *maxchar);
+
+/* === Characters Type APIs =============================================== */
+
+/* Helper array used by Py_UNICODE_ISSPACE(). */
+
+PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[];
+
+/* These should not be used directly. Use the Py_UNICODE_IS* and
+   Py_UNICODE_TO* macros instead.
+
+   These APIs are implemented in Objects/unicodectype.c.
+
+*/
+
+PyAPI_FUNC(int) _PyUnicode_IsLowercase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsUppercase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsTitlecase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsXidStart(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsXidContinue(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsWhitespace(
+    const Py_UCS4 ch         /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsLinebreak(
+    const Py_UCS4 ch         /* Unicode character */
+    );
+
+/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToLowerFull(
+    Py_UCS4 ch,       /* Unicode character */
+    Py_UCS4 *res
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToTitleFull(
+    Py_UCS4 ch,       /* Unicode character */
+    Py_UCS4 *res
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToUpperFull(
+    Py_UCS4 ch,       /* Unicode character */
+    Py_UCS4 *res
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToFoldedFull(
+    Py_UCS4 ch,       /* Unicode character */
+    Py_UCS4 *res
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsCaseIgnorable(
+    Py_UCS4 ch         /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsCased(
+    Py_UCS4 ch         /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_ToDigit(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(double) _PyUnicode_ToNumeric(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsDigit(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsNumeric(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsPrintable(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+PyAPI_FUNC(int) _PyUnicode_IsAlpha(
+    Py_UCS4 ch       /* Unicode character */
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(size_t) Py_UNICODE_strlen(
+    const Py_UNICODE *u
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcpy(
+    Py_UNICODE *s1,
+    const Py_UNICODE *s2);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcat(
+    Py_UNICODE *s1, const Py_UNICODE *s2);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strncpy(
+    Py_UNICODE *s1,
+    const Py_UNICODE *s2,
+    size_t n);
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(int) Py_UNICODE_strcmp(
+    const Py_UNICODE *s1,
+    const Py_UNICODE *s2
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(int) Py_UNICODE_strncmp(
+    const Py_UNICODE *s1,
+    const Py_UNICODE *s2,
+    size_t n
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strchr(
+    const Py_UNICODE *s,
+    Py_UNICODE c
+    );
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strrchr(
+    const Py_UNICODE *s,
+    Py_UNICODE c
+    );
+
+PyAPI_FUNC(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int);
+
+/* Create a copy of a unicode string ending with a nul character. Return NULL
+   and raise a MemoryError exception on memory allocation failure, otherwise
+   return a new allocated buffer (use PyMem_Free() to free the buffer). */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE*) PyUnicode_AsUnicodeCopy(
+    PyObject *unicode
+    );
+
+/* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/
+PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*);
+
+/* Fast equality check when the inputs are known to be exact unicode types
+   and where the hash values are equal (i.e. a very probable match) */
+PyAPI_FUNC(int) _PyUnicode_EQ(PyObject *, PyObject *);
+
+PyAPI_FUNC(Py_ssize_t) _PyUnicode_ScanIdentifier(PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/marketing/include/datetime.h b/marketing/include/datetime.h
new file mode 100644
index 0000000000000000000000000000000000000000..5d9f2558f924d0b66403348195bd7fdfbe8d30e7
--- /dev/null
+++ b/marketing/include/datetime.h
@@ -0,0 +1,259 @@
+/*  datetime.h
+ */
+#ifndef Py_LIMITED_API
+#ifndef DATETIME_H
+#define DATETIME_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Fields are packed into successive bytes, each viewed as unsigned and
+ * big-endian, unless otherwise noted:
+ *
+ * byte offset
+ *  0           year     2 bytes, 1-9999
+ *  2           month    1 byte, 1-12
+ *  3           day      1 byte, 1-31
+ *  4           hour     1 byte, 0-23
+ *  5           minute   1 byte, 0-59
+ *  6           second   1 byte, 0-59
+ *  7           usecond  3 bytes, 0-999999
+ * 10
+ */
+
+/* # of bytes for year, month, and day. */
+#define _PyDateTime_DATE_DATASIZE 4
+
+/* # of bytes for hour, minute, second, and usecond. */
+#define _PyDateTime_TIME_DATASIZE 6
+
+/* # of bytes for year, month, day, hour, minute, second, and usecond. */
+#define _PyDateTime_DATETIME_DATASIZE 10
+
+
+typedef struct
+{
+    PyObject_HEAD
+    Py_hash_t hashcode;         /* -1 when unknown */
+    int days;                   /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
+    int seconds;                /* 0 <= seconds < 24*3600 is invariant */
+    int microseconds;           /* 0 <= microseconds < 1000000 is invariant */
+} PyDateTime_Delta;
+
+typedef struct
+{
+    PyObject_HEAD               /* a pure abstract base class */
+} PyDateTime_TZInfo;
+
+
+/* The datetime and time types have hashcodes, and an optional tzinfo member,
+ * present if and only if hastzinfo is true.
+ */
+#define _PyTZINFO_HEAD          \
+    PyObject_HEAD               \
+    Py_hash_t hashcode;         \
+    char hastzinfo;             /* boolean flag */
+
+/* No _PyDateTime_BaseTZInfo is allocated; it's just to have something
+ * convenient to cast to, when getting at the hastzinfo member of objects
+ * starting with _PyTZINFO_HEAD.
+ */
+typedef struct
+{
+    _PyTZINFO_HEAD
+} _PyDateTime_BaseTZInfo;
+
+/* All time objects are of PyDateTime_TimeType, but that can be allocated
+ * in two ways, with or without a tzinfo member.  Without is the same as
+ * tzinfo == None, but consumes less memory.  _PyDateTime_BaseTime is an
+ * internal struct used to allocate the right amount of space for the
+ * "without" case.
+ */
+#define _PyDateTime_TIMEHEAD    \
+    _PyTZINFO_HEAD              \
+    unsigned char data[_PyDateTime_TIME_DATASIZE];
+
+typedef struct
+{
+    _PyDateTime_TIMEHEAD
+} _PyDateTime_BaseTime;         /* hastzinfo false */
+
+typedef struct
+{
+    _PyDateTime_TIMEHEAD
+    unsigned char fold;
+    PyObject *tzinfo;
+} PyDateTime_Time;              /* hastzinfo true */
+
+
+/* All datetime objects are of PyDateTime_DateTimeType, but that can be
+ * allocated in two ways too, just like for time objects above.  In addition,
+ * the plain date type is a base class for datetime, so it must also have
+ * a hastzinfo member (although it's unused there).
+ */
+typedef struct
+{
+    _PyTZINFO_HEAD
+    unsigned char data[_PyDateTime_DATE_DATASIZE];
+} PyDateTime_Date;
+
+#define _PyDateTime_DATETIMEHEAD        \
+    _PyTZINFO_HEAD                      \
+    unsigned char data[_PyDateTime_DATETIME_DATASIZE];
+
+typedef struct
+{
+    _PyDateTime_DATETIMEHEAD
+} _PyDateTime_BaseDateTime;     /* hastzinfo false */
+
+typedef struct
+{
+    _PyDateTime_DATETIMEHEAD
+    unsigned char fold;
+    PyObject *tzinfo;
+} PyDateTime_DateTime;          /* hastzinfo true */
+
+
+/* Apply for date and datetime instances. */
+#define PyDateTime_GET_YEAR(o)     ((((PyDateTime_Date*)o)->data[0] << 8) | \
+                     ((PyDateTime_Date*)o)->data[1])
+#define PyDateTime_GET_MONTH(o)    (((PyDateTime_Date*)o)->data[2])
+#define PyDateTime_GET_DAY(o)      (((PyDateTime_Date*)o)->data[3])
+
+#define PyDateTime_DATE_GET_HOUR(o)        (((PyDateTime_DateTime*)o)->data[4])
+#define PyDateTime_DATE_GET_MINUTE(o)      (((PyDateTime_DateTime*)o)->data[5])
+#define PyDateTime_DATE_GET_SECOND(o)      (((PyDateTime_DateTime*)o)->data[6])
+#define PyDateTime_DATE_GET_MICROSECOND(o)              \
+    ((((PyDateTime_DateTime*)o)->data[7] << 16) |       \
+     (((PyDateTime_DateTime*)o)->data[8] << 8)  |       \
+      ((PyDateTime_DateTime*)o)->data[9])
+#define PyDateTime_DATE_GET_FOLD(o)        (((PyDateTime_DateTime*)o)->fold)
+
+/* Apply for time instances. */
+#define PyDateTime_TIME_GET_HOUR(o)        (((PyDateTime_Time*)o)->data[0])
+#define PyDateTime_TIME_GET_MINUTE(o)      (((PyDateTime_Time*)o)->data[1])
+#define PyDateTime_TIME_GET_SECOND(o)      (((PyDateTime_Time*)o)->data[2])
+#define PyDateTime_TIME_GET_MICROSECOND(o)              \
+    ((((PyDateTime_Time*)o)->data[3] << 16) |           \
+     (((PyDateTime_Time*)o)->data[4] << 8)  |           \
+      ((PyDateTime_Time*)o)->data[5])
+#define PyDateTime_TIME_GET_FOLD(o)        (((PyDateTime_Time*)o)->fold)
+
+/* Apply for time delta instances */
+#define PyDateTime_DELTA_GET_DAYS(o)         (((PyDateTime_Delta*)o)->days)
+#define PyDateTime_DELTA_GET_SECONDS(o)      (((PyDateTime_Delta*)o)->seconds)
+#define PyDateTime_DELTA_GET_MICROSECONDS(o)            \
+    (((PyDateTime_Delta*)o)->microseconds)
+
+
+/* Define structure for C API. */
+typedef struct {
+    /* type objects */
+    PyTypeObject *DateType;
+    PyTypeObject *DateTimeType;
+    PyTypeObject *TimeType;
+    PyTypeObject *DeltaType;
+    PyTypeObject *TZInfoType;
+
+    /* singletons */
+    PyObject *TimeZone_UTC;
+
+    /* constructors */
+    PyObject *(*Date_FromDate)(int, int, int, PyTypeObject*);
+    PyObject *(*DateTime_FromDateAndTime)(int, int, int, int, int, int, int,
+        PyObject*, PyTypeObject*);
+    PyObject *(*Time_FromTime)(int, int, int, int, PyObject*, PyTypeObject*);
+    PyObject *(*Delta_FromDelta)(int, int, int, int, PyTypeObject*);
+    PyObject *(*TimeZone_FromTimeZone)(PyObject *offset, PyObject *name);
+
+    /* constructors for the DB API */
+    PyObject *(*DateTime_FromTimestamp)(PyObject*, PyObject*, PyObject*);
+    PyObject *(*Date_FromTimestamp)(PyObject*, PyObject*);
+
+    /* PEP 495 constructors */
+    PyObject *(*DateTime_FromDateAndTimeAndFold)(int, int, int, int, int, int, int,
+        PyObject*, int, PyTypeObject*);
+    PyObject *(*Time_FromTimeAndFold)(int, int, int, int, PyObject*, int, PyTypeObject*);
+
+} PyDateTime_CAPI;
+
+#define PyDateTime_CAPSULE_NAME "datetime.datetime_CAPI"
+
+
+/* This block is only used as part of the public API and should not be
+ * included in _datetimemodule.c, which does not use the C API capsule.
+ * See bpo-35081 for more details.
+ * */
+#ifndef _PY_DATETIME_IMPL
+/* Define global variable for the C API and a macro for setting it. */
+static PyDateTime_CAPI *PyDateTimeAPI = NULL;
+
+#define PyDateTime_IMPORT \
+    PyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0)
+
+/* Macro for access to the UTC singleton */
+#define PyDateTime_TimeZone_UTC PyDateTimeAPI->TimeZone_UTC
+
+/* Macros for type checking when not building the Python core. */
+#define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType)
+#define PyDate_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DateType)
+
+#define PyDateTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateTimeType)
+#define PyDateTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DateTimeType)
+
+#define PyTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TimeType)
+#define PyTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->TimeType)
+
+#define PyDelta_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DeltaType)
+#define PyDelta_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DeltaType)
+
+#define PyTZInfo_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TZInfoType)
+#define PyTZInfo_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->TZInfoType)
+
+
+/* Macros for accessing constructors in a simplified fashion. */
+#define PyDate_FromDate(year, month, day) \
+    PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
+
+#define PyDateTime_FromDateAndTime(year, month, day, hour, min, sec, usec) \
+    PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
+        min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
+
+#define PyDateTime_FromDateAndTimeAndFold(year, month, day, hour, min, sec, usec, fold) \
+    PyDateTimeAPI->DateTime_FromDateAndTimeAndFold(year, month, day, hour, \
+        min, sec, usec, Py_None, fold, PyDateTimeAPI->DateTimeType)
+
+#define PyTime_FromTime(hour, minute, second, usecond) \
+    PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
+        Py_None, PyDateTimeAPI->TimeType)
+
+#define PyTime_FromTimeAndFold(hour, minute, second, usecond, fold) \
+    PyDateTimeAPI->Time_FromTimeAndFold(hour, minute, second, usecond, \
+        Py_None, fold, PyDateTimeAPI->TimeType)
+
+#define PyDelta_FromDSU(days, seconds, useconds) \
+    PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
+        PyDateTimeAPI->DeltaType)
+
+#define PyTimeZone_FromOffset(offset) \
+    PyDateTimeAPI->TimeZone_FromTimeZone(offset, NULL)
+
+#define PyTimeZone_FromOffsetAndName(offset, name) \
+    PyDateTimeAPI->TimeZone_FromTimeZone(offset, name)
+
+/* Macros supporting the DB API. */
+#define PyDateTime_FromTimestamp(args) \
+    PyDateTimeAPI->DateTime_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
+
+#define PyDate_FromTimestamp(args) \
+    PyDateTimeAPI->Date_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateType), args)
+
+#endif   /* !defined(_PY_DATETIME_IMPL) */
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif /* !Py_LIMITED_API */
diff --git a/marketing/include/descrobject.h b/marketing/include/descrobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..ead269d1d2f796b5f4cf9c00284f9da7f5e79964
--- /dev/null
+++ b/marketing/include/descrobject.h
@@ -0,0 +1,108 @@
+/* Descriptors */
+#ifndef Py_DESCROBJECT_H
+#define Py_DESCROBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef PyObject *(*getter)(PyObject *, void *);
+typedef int (*setter)(PyObject *, PyObject *, void *);
+
+typedef struct PyGetSetDef {
+    const char *name;
+    getter get;
+    setter set;
+    const char *doc;
+    void *closure;
+} PyGetSetDef;
+
+#ifndef Py_LIMITED_API
+typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args,
+                                 void *wrapped);
+
+typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args,
+                                      void *wrapped, PyObject *kwds);
+
+struct wrapperbase {
+    const char *name;
+    int offset;
+    void *function;
+    wrapperfunc wrapper;
+    const char *doc;
+    int flags;
+    PyObject *name_strobj;
+};
+
+/* Flags for above struct */
+#define PyWrapperFlag_KEYWORDS 1 /* wrapper function takes keyword args */
+
+/* Various kinds of descriptor objects */
+
+typedef struct {
+    PyObject_HEAD
+    PyTypeObject *d_type;
+    PyObject *d_name;
+    PyObject *d_qualname;
+} PyDescrObject;
+
+#define PyDescr_COMMON PyDescrObject d_common
+
+#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
+#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
+
+typedef struct {
+    PyDescr_COMMON;
+    PyMethodDef *d_method;
+    vectorcallfunc vectorcall;
+} PyMethodDescrObject;
+
+typedef struct {
+    PyDescr_COMMON;
+    struct PyMemberDef *d_member;
+} PyMemberDescrObject;
+
+typedef struct {
+    PyDescr_COMMON;
+    PyGetSetDef *d_getset;
+} PyGetSetDescrObject;
+
+typedef struct {
+    PyDescr_COMMON;
+    struct wrapperbase *d_base;
+    void *d_wrapped; /* This can be any function pointer */
+} PyWrapperDescrObject;
+#endif /* Py_LIMITED_API */
+
+PyAPI_DATA(PyTypeObject) PyClassMethodDescr_Type;
+PyAPI_DATA(PyTypeObject) PyGetSetDescr_Type;
+PyAPI_DATA(PyTypeObject) PyMemberDescr_Type;
+PyAPI_DATA(PyTypeObject) PyMethodDescr_Type;
+PyAPI_DATA(PyTypeObject) PyWrapperDescr_Type;
+PyAPI_DATA(PyTypeObject) PyDictProxy_Type;
+#ifndef Py_LIMITED_API
+PyAPI_DATA(PyTypeObject) _PyMethodWrapper_Type;
+#endif /* Py_LIMITED_API */
+
+PyAPI_FUNC(PyObject *) PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
+PyAPI_FUNC(PyObject *) PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);
+struct PyMemberDef; /* forward declaration for following prototype */
+PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *,
+                                               struct PyMemberDef *);
+PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *,
+                                               struct PyGetSetDef *);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *,
+                                                struct wrapperbase *, void *);
+#define PyDescr_IsData(d) (Py_TYPE(d)->tp_descr_set != NULL)
+#endif
+
+PyAPI_FUNC(PyObject *) PyDictProxy_New(PyObject *);
+PyAPI_FUNC(PyObject *) PyWrapper_New(PyObject *, PyObject *);
+
+
+PyAPI_DATA(PyTypeObject) PyProperty_Type;
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_DESCROBJECT_H */
+
diff --git a/marketing/include/dictobject.h b/marketing/include/dictobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..c88b0aa0a5d0f96aab1d17a4c001c72cc633ef14
--- /dev/null
+++ b/marketing/include/dictobject.h
@@ -0,0 +1,94 @@
+#ifndef Py_DICTOBJECT_H
+#define Py_DICTOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dictionary object type -- mapping from hashable object to object */
+
+/* The distribution includes a separate file, Objects/dictnotes.txt,
+   describing explorations into dictionary design and optimization.
+   It covers typical dictionary use patterns, the parameters for
+   tuning dictionaries, and several ideas for possible optimizations.
+*/
+
+PyAPI_DATA(PyTypeObject) PyDict_Type;
+
+#define PyDict_Check(op) \
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)
+#define PyDict_CheckExact(op) Py_IS_TYPE(op, &PyDict_Type)
+
+PyAPI_FUNC(PyObject *) PyDict_New(void);
+PyAPI_FUNC(PyObject *) PyDict_GetItem(PyObject *mp, PyObject *key);
+PyAPI_FUNC(PyObject *) PyDict_GetItemWithError(PyObject *mp, PyObject *key);
+PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
+PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key);
+PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
+PyAPI_FUNC(int) PyDict_Next(
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
+PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp);
+PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp);
+PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp);
+PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp);
+PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp);
+PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key);
+
+/* PyDict_Update(mp, other) is equivalent to PyDict_Merge(mp, other, 1). */
+PyAPI_FUNC(int) PyDict_Update(PyObject *mp, PyObject *other);
+
+/* PyDict_Merge updates/merges from a mapping object (an object that
+   supports PyMapping_Keys() and PyObject_GetItem()).  If override is true,
+   the last occurrence of a key wins, else the first.  The Python
+   dict.update(other) is equivalent to PyDict_Merge(dict, other, 1).
+*/
+PyAPI_FUNC(int) PyDict_Merge(PyObject *mp,
+                             PyObject *other,
+                             int override);
+
+/* PyDict_MergeFromSeq2 updates/merges from an iterable object producing
+   iterable objects of length 2.  If override is true, the last occurrence
+   of a key wins, else the first.  The Python dict constructor dict(seq2)
+   is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1).
+*/
+PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d,
+                                     PyObject *seq2,
+                                     int override);
+
+PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key);
+PyAPI_FUNC(int) PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item);
+PyAPI_FUNC(int) PyDict_DelItemString(PyObject *dp, const char *key);
+
+/* Dictionary (keys, values, items) views */
+
+PyAPI_DATA(PyTypeObject) PyDictKeys_Type;
+PyAPI_DATA(PyTypeObject) PyDictValues_Type;
+PyAPI_DATA(PyTypeObject) PyDictItems_Type;
+
+#define PyDictKeys_Check(op) PyObject_TypeCheck(op, &PyDictKeys_Type)
+#define PyDictValues_Check(op) PyObject_TypeCheck(op, &PyDictValues_Type)
+#define PyDictItems_Check(op) PyObject_TypeCheck(op, &PyDictItems_Type)
+/* This excludes Values, since they are not sets. */
+# define PyDictViewSet_Check(op) \
+    (PyDictKeys_Check(op) || PyDictItems_Check(op))
+
+/* Dictionary (key, value, items) iterators */
+
+PyAPI_DATA(PyTypeObject) PyDictIterKey_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterValue_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterItem_Type;
+
+PyAPI_DATA(PyTypeObject) PyDictRevIterKey_Type;
+PyAPI_DATA(PyTypeObject) PyDictRevIterItem_Type;
+PyAPI_DATA(PyTypeObject) PyDictRevIterValue_Type;
+
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_DICTOBJECT_H
+#  include  "cpython/dictobject.h"
+#  undef Py_CPYTHON_DICTOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_DICTOBJECT_H */
diff --git a/marketing/include/dynamic_annotations.h b/marketing/include/dynamic_annotations.h
new file mode 100644
index 0000000000000000000000000000000000000000..0bd1a833c2e5a54ef951321abe83f5d693d5d39c
--- /dev/null
+++ b/marketing/include/dynamic_annotations.h
@@ -0,0 +1,499 @@
+/* Copyright (c) 2008-2009, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ---
+ * Author: Kostya Serebryany
+ * Copied to CPython by Jeffrey Yasskin, with all macros renamed to
+ * start with _Py_ to avoid colliding with users embedding Python, and
+ * with deprecated macros removed.
+ */
+
+/* This file defines dynamic annotations for use with dynamic analysis
+   tool such as valgrind, PIN, etc.
+
+   Dynamic annotation is a source code annotation that affects
+   the generated code (that is, the annotation is not a comment).
+   Each such annotation is attached to a particular
+   instruction and/or to a particular object (address) in the program.
+
+   The annotations that should be used by users are macros in all upper-case
+   (e.g., _Py_ANNOTATE_NEW_MEMORY).
+
+   Actual implementation of these macros may differ depending on the
+   dynamic analysis tool being used.
+
+   See http://code.google.com/p/data-race-test/  for more information.
+
+   This file supports the following dynamic analysis tools:
+   - None (DYNAMIC_ANNOTATIONS_ENABLED is not defined or zero).
+      Macros are defined empty.
+   - ThreadSanitizer, Helgrind, DRD (DYNAMIC_ANNOTATIONS_ENABLED is 1).
+      Macros are defined as calls to non-inlinable empty functions
+      that are intercepted by Valgrind. */
+
+#ifndef __DYNAMIC_ANNOTATIONS_H__
+#define __DYNAMIC_ANNOTATIONS_H__
+
+#ifndef DYNAMIC_ANNOTATIONS_ENABLED
+# define DYNAMIC_ANNOTATIONS_ENABLED 0
+#endif
+
+#if DYNAMIC_ANNOTATIONS_ENABLED != 0
+
+  /* -------------------------------------------------------------
+     Annotations useful when implementing condition variables such as CondVar,
+     using conditional critical sections (Await/LockWhen) and when constructing
+     user-defined synchronization mechanisms.
+
+     The annotations _Py_ANNOTATE_HAPPENS_BEFORE() and
+     _Py_ANNOTATE_HAPPENS_AFTER() can be used to define happens-before arcs in
+     user-defined synchronization mechanisms: the race detector will infer an
+     arc from the former to the latter when they share the same argument
+     pointer.
+
+     Example 1 (reference counting):
+
+     void Unref() {
+       _Py_ANNOTATE_HAPPENS_BEFORE(&refcount_);
+       if (AtomicDecrementByOne(&refcount_) == 0) {
+         _Py_ANNOTATE_HAPPENS_AFTER(&refcount_);
+         delete this;
+       }
+     }
+
+     Example 2 (message queue):
+
+     void MyQueue::Put(Type *e) {
+       MutexLock lock(&mu_);
+       _Py_ANNOTATE_HAPPENS_BEFORE(e);
+       PutElementIntoMyQueue(e);
+     }
+
+     Type *MyQueue::Get() {
+       MutexLock lock(&mu_);
+       Type *e = GetElementFromMyQueue();
+       _Py_ANNOTATE_HAPPENS_AFTER(e);
+       return e;
+     }
+
+     Note: when possible, please use the existing reference counting and message
+     queue implementations instead of inventing new ones. */
+
+  /* Report that wait on the condition variable at address "cv" has succeeded
+     and the lock at address "lock" is held. */
+#define _Py_ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) \
+    AnnotateCondVarWait(__FILE__, __LINE__, cv, lock)
+
+  /* Report that wait on the condition variable at "cv" has succeeded.  Variant
+     w/o lock. */
+#define _Py_ANNOTATE_CONDVAR_WAIT(cv) \
+    AnnotateCondVarWait(__FILE__, __LINE__, cv, NULL)
+
+  /* Report that we are about to signal on the condition variable at address
+     "cv". */
+#define _Py_ANNOTATE_CONDVAR_SIGNAL(cv) \
+    AnnotateCondVarSignal(__FILE__, __LINE__, cv)
+
+  /* Report that we are about to signal_all on the condition variable at "cv". */
+#define _Py_ANNOTATE_CONDVAR_SIGNAL_ALL(cv) \
+    AnnotateCondVarSignalAll(__FILE__, __LINE__, cv)
+
+  /* Annotations for user-defined synchronization mechanisms. */
+#define _Py_ANNOTATE_HAPPENS_BEFORE(obj) _Py_ANNOTATE_CONDVAR_SIGNAL(obj)
+#define _Py_ANNOTATE_HAPPENS_AFTER(obj)  _Py_ANNOTATE_CONDVAR_WAIT(obj)
+
+  /* Report that the bytes in the range [pointer, pointer+size) are about
+     to be published safely. The race checker will create a happens-before
+     arc from the call _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) to
+     subsequent accesses to this memory.
+     Note: this annotation may not work properly if the race detector uses
+     sampling, i.e. does not observe all memory accesses.
+     */
+#define _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(pointer, size) \
+    AnnotatePublishMemoryRange(__FILE__, __LINE__, pointer, size)
+
+  /* Instruct the tool to create a happens-before arc between mu->Unlock() and
+     mu->Lock(). This annotation may slow down the race detector and hide real
+     races. Normally it is used only when it would be difficult to annotate each
+     of the mutex's critical sections individually using the annotations above.
+     This annotation makes sense only for hybrid race detectors. For pure
+     happens-before detectors this is a no-op. For more details see
+     http://code.google.com/p/data-race-test/wiki/PureHappensBeforeVsHybrid . */
+#define _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) \
+    AnnotateMutexIsUsedAsCondVar(__FILE__, __LINE__, mu)
+
+  /* -------------------------------------------------------------
+     Annotations useful when defining memory allocators, or when memory that
+     was protected in one way starts to be protected in another. */
+
+  /* Report that a new memory at "address" of size "size" has been allocated.
+     This might be used when the memory has been retrieved from a free list and
+     is about to be reused, or when the locking discipline for a variable
+     changes. */
+#define _Py_ANNOTATE_NEW_MEMORY(address, size) \
+    AnnotateNewMemory(__FILE__, __LINE__, address, size)
+
+  /* -------------------------------------------------------------
+     Annotations useful when defining FIFO queues that transfer data between
+     threads. */
+
+  /* Report that the producer-consumer queue (such as ProducerConsumerQueue) at
+     address "pcq" has been created.  The _Py_ANNOTATE_PCQ_* annotations should
+     be used only for FIFO queues.  For non-FIFO queues use
+     _Py_ANNOTATE_HAPPENS_BEFORE (for put) and _Py_ANNOTATE_HAPPENS_AFTER (for
+     get). */
+#define _Py_ANNOTATE_PCQ_CREATE(pcq) \
+    AnnotatePCQCreate(__FILE__, __LINE__, pcq)
+
+  /* Report that the queue at address "pcq" is about to be destroyed. */
+#define _Py_ANNOTATE_PCQ_DESTROY(pcq) \
+    AnnotatePCQDestroy(__FILE__, __LINE__, pcq)
+
+  /* Report that we are about to put an element into a FIFO queue at address
+     "pcq". */
+#define _Py_ANNOTATE_PCQ_PUT(pcq) \
+    AnnotatePCQPut(__FILE__, __LINE__, pcq)
+
+  /* Report that we've just got an element from a FIFO queue at address "pcq". */
+#define _Py_ANNOTATE_PCQ_GET(pcq) \
+    AnnotatePCQGet(__FILE__, __LINE__, pcq)
+
+  /* -------------------------------------------------------------
+     Annotations that suppress errors.  It is usually better to express the
+     program's synchronization using the other annotations, but these can
+     be used when all else fails. */
+
+  /* Report that we may have a benign race at "pointer", with size
+     "sizeof(*(pointer))". "pointer" must be a non-void* pointer.  Insert at the
+     point where "pointer" has been allocated, preferably close to the point
+     where the race happens.  See also _Py_ANNOTATE_BENIGN_RACE_STATIC. */
+#define _Py_ANNOTATE_BENIGN_RACE(pointer, description) \
+    AnnotateBenignRaceSized(__FILE__, __LINE__, pointer, \
+                            sizeof(*(pointer)), description)
+
+  /* Same as _Py_ANNOTATE_BENIGN_RACE(address, description), but applies to
+     the memory range [address, address+size). */
+#define _Py_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
+    AnnotateBenignRaceSized(__FILE__, __LINE__, address, size, description)
+
+  /* Request the analysis tool to ignore all reads in the current thread
+     until _Py_ANNOTATE_IGNORE_READS_END is called.
+     Useful to ignore intentional racey reads, while still checking
+     other reads and all writes.
+     See also _Py_ANNOTATE_UNPROTECTED_READ. */
+#define _Py_ANNOTATE_IGNORE_READS_BEGIN() \
+    AnnotateIgnoreReadsBegin(__FILE__, __LINE__)
+
+  /* Stop ignoring reads. */
+#define _Py_ANNOTATE_IGNORE_READS_END() \
+    AnnotateIgnoreReadsEnd(__FILE__, __LINE__)
+
+  /* Similar to _Py_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes. */
+#define _Py_ANNOTATE_IGNORE_WRITES_BEGIN() \
+    AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
+
+  /* Stop ignoring writes. */
+#define _Py_ANNOTATE_IGNORE_WRITES_END() \
+    AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
+
+  /* Start ignoring all memory accesses (reads and writes). */
+#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
+    do {\
+      _Py_ANNOTATE_IGNORE_READS_BEGIN();\
+      _Py_ANNOTATE_IGNORE_WRITES_BEGIN();\
+    }while(0)\
+
+  /* Stop ignoring all memory accesses. */
+#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_END() \
+    do {\
+      _Py_ANNOTATE_IGNORE_WRITES_END();\
+      _Py_ANNOTATE_IGNORE_READS_END();\
+    }while(0)\
+
+  /* Similar to _Py_ANNOTATE_IGNORE_READS_BEGIN, but ignore synchronization events:
+     RWLOCK* and CONDVAR*. */
+#define _Py_ANNOTATE_IGNORE_SYNC_BEGIN() \
+    AnnotateIgnoreSyncBegin(__FILE__, __LINE__)
+
+  /* Stop ignoring sync events. */
+#define _Py_ANNOTATE_IGNORE_SYNC_END() \
+    AnnotateIgnoreSyncEnd(__FILE__, __LINE__)
+
+
+  /* Enable (enable!=0) or disable (enable==0) race detection for all threads.
+     This annotation could be useful if you want to skip expensive race analysis
+     during some period of program execution, e.g. during initialization. */
+#define _Py_ANNOTATE_ENABLE_RACE_DETECTION(enable) \
+    AnnotateEnableRaceDetection(__FILE__, __LINE__, enable)
+
+  /* -------------------------------------------------------------
+     Annotations useful for debugging. */
+
+  /* Request to trace every access to "address". */
+#define _Py_ANNOTATE_TRACE_MEMORY(address) \
+    AnnotateTraceMemory(__FILE__, __LINE__, address)
+
+  /* Report the current thread name to a race detector. */
+#define _Py_ANNOTATE_THREAD_NAME(name) \
+    AnnotateThreadName(__FILE__, __LINE__, name)
+
+  /* -------------------------------------------------------------
+     Annotations useful when implementing locks.  They are not
+     normally needed by modules that merely use locks.
+     The "lock" argument is a pointer to the lock object. */
+
+  /* Report that a lock has been created at address "lock". */
+#define _Py_ANNOTATE_RWLOCK_CREATE(lock) \
+    AnnotateRWLockCreate(__FILE__, __LINE__, lock)
+
+  /* Report that the lock at address "lock" is about to be destroyed. */
+#define _Py_ANNOTATE_RWLOCK_DESTROY(lock) \
+    AnnotateRWLockDestroy(__FILE__, __LINE__, lock)
+
+  /* Report that the lock at address "lock" has been acquired.
+     is_w=1 for writer lock, is_w=0 for reader lock. */
+#define _Py_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) \
+    AnnotateRWLockAcquired(__FILE__, __LINE__, lock, is_w)
+
+  /* Report that the lock at address "lock" is about to be released. */
+#define _Py_ANNOTATE_RWLOCK_RELEASED(lock, is_w) \
+    AnnotateRWLockReleased(__FILE__, __LINE__, lock, is_w)
+
+  /* -------------------------------------------------------------
+     Annotations useful when implementing barriers.  They are not
+     normally needed by modules that merely use barriers.
+     The "barrier" argument is a pointer to the barrier object. */
+
+  /* Report that the "barrier" has been initialized with initial "count".
+   If 'reinitialization_allowed' is true, initialization is allowed to happen
+   multiple times w/o calling barrier_destroy() */
+#define _Py_ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \
+    AnnotateBarrierInit(__FILE__, __LINE__, barrier, count, \
+                        reinitialization_allowed)
+
+  /* Report that we are about to enter barrier_wait("barrier"). */
+#define _Py_ANNOTATE_BARRIER_WAIT_BEFORE(barrier) \
+    AnnotateBarrierWaitBefore(__FILE__, __LINE__, barrier)
+
+  /* Report that we just exited barrier_wait("barrier"). */
+#define _Py_ANNOTATE_BARRIER_WAIT_AFTER(barrier) \
+    AnnotateBarrierWaitAfter(__FILE__, __LINE__, barrier)
+
+  /* Report that the "barrier" has been destroyed. */
+#define _Py_ANNOTATE_BARRIER_DESTROY(barrier) \
+    AnnotateBarrierDestroy(__FILE__, __LINE__, barrier)
+
+  /* -------------------------------------------------------------
+     Annotations useful for testing race detectors. */
+
+  /* Report that we expect a race on the variable at "address".
+     Use only in unit tests for a race detector. */
+#define _Py_ANNOTATE_EXPECT_RACE(address, description) \
+    AnnotateExpectRace(__FILE__, __LINE__, address, description)
+
+  /* A no-op. Insert where you like to test the interceptors. */
+#define _Py_ANNOTATE_NO_OP(arg) \
+    AnnotateNoOp(__FILE__, __LINE__, arg)
+
+  /* Force the race detector to flush its state. The actual effect depends on
+   * the implementation of the detector. */
+#define _Py_ANNOTATE_FLUSH_STATE() \
+    AnnotateFlushState(__FILE__, __LINE__)
+
+
+#else  /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */
+
+#define _Py_ANNOTATE_RWLOCK_CREATE(lock) /* empty */
+#define _Py_ANNOTATE_RWLOCK_DESTROY(lock) /* empty */
+#define _Py_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) /* empty */
+#define _Py_ANNOTATE_RWLOCK_RELEASED(lock, is_w) /* empty */
+#define _Py_ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) /* */
+#define _Py_ANNOTATE_BARRIER_WAIT_BEFORE(barrier) /* empty */
+#define _Py_ANNOTATE_BARRIER_WAIT_AFTER(barrier) /* empty */
+#define _Py_ANNOTATE_BARRIER_DESTROY(barrier) /* empty */
+#define _Py_ANNOTATE_CONDVAR_LOCK_WAIT(cv, lock) /* empty */
+#define _Py_ANNOTATE_CONDVAR_WAIT(cv) /* empty */
+#define _Py_ANNOTATE_CONDVAR_SIGNAL(cv) /* empty */
+#define _Py_ANNOTATE_CONDVAR_SIGNAL_ALL(cv) /* empty */
+#define _Py_ANNOTATE_HAPPENS_BEFORE(obj) /* empty */
+#define _Py_ANNOTATE_HAPPENS_AFTER(obj) /* empty */
+#define _Py_ANNOTATE_PUBLISH_MEMORY_RANGE(address, size) /* empty */
+#define _Py_ANNOTATE_UNPUBLISH_MEMORY_RANGE(address, size)  /* empty */
+#define _Py_ANNOTATE_SWAP_MEMORY_RANGE(address, size)  /* empty */
+#define _Py_ANNOTATE_PCQ_CREATE(pcq) /* empty */
+#define _Py_ANNOTATE_PCQ_DESTROY(pcq) /* empty */
+#define _Py_ANNOTATE_PCQ_PUT(pcq) /* empty */
+#define _Py_ANNOTATE_PCQ_GET(pcq) /* empty */
+#define _Py_ANNOTATE_NEW_MEMORY(address, size) /* empty */
+#define _Py_ANNOTATE_EXPECT_RACE(address, description) /* empty */
+#define _Py_ANNOTATE_BENIGN_RACE(address, description) /* empty */
+#define _Py_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) /* empty */
+#define _Py_ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mu) /* empty */
+#define _Py_ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mu) /* empty */
+#define _Py_ANNOTATE_TRACE_MEMORY(arg) /* empty */
+#define _Py_ANNOTATE_THREAD_NAME(name) /* empty */
+#define _Py_ANNOTATE_IGNORE_READS_BEGIN() /* empty */
+#define _Py_ANNOTATE_IGNORE_READS_END() /* empty */
+#define _Py_ANNOTATE_IGNORE_WRITES_BEGIN() /* empty */
+#define _Py_ANNOTATE_IGNORE_WRITES_END() /* empty */
+#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() /* empty */
+#define _Py_ANNOTATE_IGNORE_READS_AND_WRITES_END() /* empty */
+#define _Py_ANNOTATE_IGNORE_SYNC_BEGIN() /* empty */
+#define _Py_ANNOTATE_IGNORE_SYNC_END() /* empty */
+#define _Py_ANNOTATE_ENABLE_RACE_DETECTION(enable) /* empty */
+#define _Py_ANNOTATE_NO_OP(arg) /* empty */
+#define _Py_ANNOTATE_FLUSH_STATE() /* empty */
+
+#endif  /* DYNAMIC_ANNOTATIONS_ENABLED */
+
+/* Use the macros above rather than using these functions directly. */
+#ifdef __cplusplus
+extern "C" {
+#endif
+void AnnotateRWLockCreate(const char *file, int line,
+                          const volatile void *lock);
+void AnnotateRWLockDestroy(const char *file, int line,
+                           const volatile void *lock);
+void AnnotateRWLockAcquired(const char *file, int line,
+                            const volatile void *lock, long is_w);
+void AnnotateRWLockReleased(const char *file, int line,
+                            const volatile void *lock, long is_w);
+void AnnotateBarrierInit(const char *file, int line,
+                         const volatile void *barrier, long count,
+                         long reinitialization_allowed);
+void AnnotateBarrierWaitBefore(const char *file, int line,
+                               const volatile void *barrier);
+void AnnotateBarrierWaitAfter(const char *file, int line,
+                              const volatile void *barrier);
+void AnnotateBarrierDestroy(const char *file, int line,
+                            const volatile void *barrier);
+void AnnotateCondVarWait(const char *file, int line,
+                         const volatile void *cv,
+                         const volatile void *lock);
+void AnnotateCondVarSignal(const char *file, int line,
+                           const volatile void *cv);
+void AnnotateCondVarSignalAll(const char *file, int line,
+                              const volatile void *cv);
+void AnnotatePublishMemoryRange(const char *file, int line,
+                                const volatile void *address,
+                                long size);
+void AnnotateUnpublishMemoryRange(const char *file, int line,
+                                  const volatile void *address,
+                                  long size);
+void AnnotatePCQCreate(const char *file, int line,
+                       const volatile void *pcq);
+void AnnotatePCQDestroy(const char *file, int line,
+                        const volatile void *pcq);
+void AnnotatePCQPut(const char *file, int line,
+                    const volatile void *pcq);
+void AnnotatePCQGet(const char *file, int line,
+                    const volatile void *pcq);
+void AnnotateNewMemory(const char *file, int line,
+                       const volatile void *address,
+                       long size);
+void AnnotateExpectRace(const char *file, int line,
+                        const volatile void *address,
+                        const char *description);
+void AnnotateBenignRace(const char *file, int line,
+                        const volatile void *address,
+                        const char *description);
+void AnnotateBenignRaceSized(const char *file, int line,
+                        const volatile void *address,
+                        long size,
+                        const char *description);
+void AnnotateMutexIsUsedAsCondVar(const char *file, int line,
+                                  const volatile void *mu);
+void AnnotateTraceMemory(const char *file, int line,
+                         const volatile void *arg);
+void AnnotateThreadName(const char *file, int line,
+                        const char *name);
+void AnnotateIgnoreReadsBegin(const char *file, int line);
+void AnnotateIgnoreReadsEnd(const char *file, int line);
+void AnnotateIgnoreWritesBegin(const char *file, int line);
+void AnnotateIgnoreWritesEnd(const char *file, int line);
+void AnnotateEnableRaceDetection(const char *file, int line, int enable);
+void AnnotateNoOp(const char *file, int line,
+                  const volatile void *arg);
+void AnnotateFlushState(const char *file, int line);
+
+/* Return non-zero value if running under valgrind.
+
+  If "valgrind.h" is included into dynamic_annotations.c,
+  the regular valgrind mechanism will be used.
+  See http://valgrind.org/docs/manual/manual-core-adv.html about
+  RUNNING_ON_VALGRIND and other valgrind "client requests".
+  The file "valgrind.h" may be obtained by doing
+     svn co svn://svn.valgrind.org/valgrind/trunk/include
+
+  If for some reason you can't use "valgrind.h" or want to fake valgrind,
+  there are two ways to make this function return non-zero:
+    - Use environment variable: export RUNNING_ON_VALGRIND=1
+    - Make your tool intercept the function RunningOnValgrind() and
+      change its return value.
+ */
+int RunningOnValgrind(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#if DYNAMIC_ANNOTATIONS_ENABLED != 0 && defined(__cplusplus)
+
+  /* _Py_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
+
+     Instead of doing
+        _Py_ANNOTATE_IGNORE_READS_BEGIN();
+        ... = x;
+        _Py_ANNOTATE_IGNORE_READS_END();
+     one can use
+        ... = _Py_ANNOTATE_UNPROTECTED_READ(x); */
+  template 
+  inline T _Py_ANNOTATE_UNPROTECTED_READ(const volatile T &x) {
+    _Py_ANNOTATE_IGNORE_READS_BEGIN();
+    T res = x;
+    _Py_ANNOTATE_IGNORE_READS_END();
+    return res;
+  }
+  /* Apply _Py_ANNOTATE_BENIGN_RACE_SIZED to a static variable. */
+#define _Py_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)        \
+    namespace {                                                       \
+      class static_var ## _annotator {                                \
+       public:                                                        \
+        static_var ## _annotator() {                                  \
+          _Py_ANNOTATE_BENIGN_RACE_SIZED(&static_var,                     \
+                                      sizeof(static_var),             \
+            # static_var ": " description);                           \
+        }                                                             \
+      };                                                              \
+      static static_var ## _annotator the ## static_var ## _annotator;\
+    }
+#else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */
+
+#define _Py_ANNOTATE_UNPROTECTED_READ(x) (x)
+#define _Py_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)  /* empty */
+
+#endif /* DYNAMIC_ANNOTATIONS_ENABLED */
+
+#endif  /* __DYNAMIC_ANNOTATIONS_H__ */
diff --git a/marketing/include/enumobject.h b/marketing/include/enumobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..c14dbfc8c37e7c9316b9cca0a5969ee925d729d8
--- /dev/null
+++ b/marketing/include/enumobject.h
@@ -0,0 +1,17 @@
+#ifndef Py_ENUMOBJECT_H
+#define Py_ENUMOBJECT_H
+
+/* Enumerate Object */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyEnum_Type;
+PyAPI_DATA(PyTypeObject) PyReversed_Type;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_ENUMOBJECT_H */
diff --git a/marketing/include/errcode.h b/marketing/include/errcode.h
new file mode 100644
index 0000000000000000000000000000000000000000..790518b8b7730ed5e24a64d0e99f9c921b48d8ec
--- /dev/null
+++ b/marketing/include/errcode.h
@@ -0,0 +1,37 @@
+#ifndef Py_ERRCODE_H
+#define Py_ERRCODE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Error codes passed around between file input, tokenizer, parser and
+   interpreter.  This is necessary so we can turn them into Python
+   exceptions at a higher level.  Note that some errors have a
+   slightly different meaning when passed from the tokenizer to the
+   parser than when passed from the parser to the interpreter; e.g.
+   the parser only returns E_EOF when it hits EOF immediately, and it
+   never returns E_OK. */
+
+#define E_OK            10      /* No error */
+#define E_EOF           11      /* End Of File */
+#define E_INTR          12      /* Interrupted */
+#define E_TOKEN         13      /* Bad token */
+#define E_SYNTAX        14      /* Syntax error */
+#define E_NOMEM         15      /* Ran out of memory */
+#define E_DONE          16      /* Parsing complete */
+#define E_ERROR         17      /* Execution error */
+#define E_TABSPACE      18      /* Inconsistent mixing of tabs and spaces */
+#define E_OVERFLOW      19      /* Node had too many children */
+#define E_TOODEEP       20      /* Too many indentation levels */
+#define E_DEDENT        21      /* No matching outer block for dedent */
+#define E_DECODE        22      /* Error in decoding into Unicode */
+#define E_EOFS          23      /* EOF in triple-quoted string */
+#define E_EOLS          24      /* EOL in single-quoted string */
+#define E_LINECONT      25      /* Unexpected characters after a line continuation */
+#define E_BADSINGLE     27      /* Ill-formed single statement input */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_ERRCODE_H */
diff --git a/marketing/include/eval.h b/marketing/include/eval.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c1c2d0549a9a40fcf054adf9b7138fa851f78ce
--- /dev/null
+++ b/marketing/include/eval.h
@@ -0,0 +1,37 @@
+
+/* Interface to execute compiled code */
+
+#ifndef Py_EVAL_H
+#define Py_EVAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(PyObject *) PyEval_EvalCode(PyObject *, PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) PyEval_EvalCodeEx(PyObject *co,
+                                         PyObject *globals,
+                                         PyObject *locals,
+                                         PyObject *const *args, int argc,
+                                         PyObject *const *kwds, int kwdc,
+                                         PyObject *const *defs, int defc,
+                                         PyObject *kwdefs, PyObject *closure);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _PyEval_EvalCodeWithName(
+    PyObject *co,
+    PyObject *globals, PyObject *locals,
+    PyObject *const *args, Py_ssize_t argcount,
+    PyObject *const *kwnames, PyObject *const *kwargs,
+    Py_ssize_t kwcount, int kwstep,
+    PyObject *const *defs, Py_ssize_t defcount,
+    PyObject *kwdefs, PyObject *closure,
+    PyObject *name, PyObject *qualname);
+
+PyAPI_FUNC(PyObject *) _PyEval_CallTracing(PyObject *func, PyObject *args);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_EVAL_H */
diff --git a/marketing/include/exports.h b/marketing/include/exports.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc1a5c5ead6276e856de8e07080a125375a8acd0
--- /dev/null
+++ b/marketing/include/exports.h
@@ -0,0 +1,30 @@
+#ifndef Py_EXPORTS_H
+#define Py_EXPORTS_H
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+    #define Py_IMPORTED_SYMBOL __declspec(dllimport)
+    #define Py_EXPORTED_SYMBOL __declspec(dllexport)
+    #define Py_LOCAL_SYMBOL
+#else
+/*
+ * If we only ever used gcc >= 5, we could use __has_attribute(visibility)
+ * as a cross-platform way to determine if visibility is supported. However,
+ * we may still need to support gcc >= 4, as some Ubuntu LTS and Centos versions
+ * have 4 < gcc < 5.
+ */
+    #ifndef __has_attribute
+      #define __has_attribute(x) 0  // Compatibility with non-clang compilers.
+    #endif
+    #if (defined(__GNUC__) && (__GNUC__ >= 4)) ||\
+        (defined(__clang__) && __has_attribute(visibility))
+        #define Py_IMPORTED_SYMBOL __attribute__ ((visibility ("default")))
+        #define Py_EXPORTED_SYMBOL __attribute__ ((visibility ("default")))
+        #define Py_LOCAL_SYMBOL  __attribute__ ((visibility ("hidden")))
+    #else
+        #define Py_IMPORTED_SYMBOL
+        #define Py_EXPORTED_SYMBOL
+        #define Py_LOCAL_SYMBOL
+    #endif
+#endif
+
+#endif /* Py_EXPORTS_H */
diff --git a/marketing/include/fileobject.h b/marketing/include/fileobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ec2994aa859b6fbcd71d12fd283733ea1d049ab
--- /dev/null
+++ b/marketing/include/fileobject.h
@@ -0,0 +1,49 @@
+/* File object interface (what's left of it -- see io.py) */
+
+#ifndef Py_FILEOBJECT_H
+#define Py_FILEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PY_STDIOTEXTMODE "b"
+
+PyAPI_FUNC(PyObject *) PyFile_FromFd(int, const char *, const char *, int,
+                                     const char *, const char *,
+                                     const char *, int);
+PyAPI_FUNC(PyObject *) PyFile_GetLine(PyObject *, int);
+PyAPI_FUNC(int) PyFile_WriteObject(PyObject *, PyObject *, int);
+PyAPI_FUNC(int) PyFile_WriteString(const char *, PyObject *);
+PyAPI_FUNC(int) PyObject_AsFileDescriptor(PyObject *);
+
+/* The default encoding used by the platform file system APIs
+   If non-NULL, this is different than the default encoding for strings
+*/
+PyAPI_DATA(const char *) Py_FileSystemDefaultEncoding;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+PyAPI_DATA(const char *) Py_FileSystemDefaultEncodeErrors;
+#endif
+PyAPI_DATA(int) Py_HasFileSystemDefaultEncoding;
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
+PyAPI_DATA(int) Py_UTF8Mode;
+#endif
+
+/* A routine to check if a file descriptor can be select()-ed. */
+#ifdef _MSC_VER
+    /* On Windows, any socket fd can be select()-ed, no matter how high */
+    #define _PyIsSelectable_fd(FD) (1)
+#else
+    #define _PyIsSelectable_fd(FD) ((unsigned int)(FD) < (unsigned int)FD_SETSIZE)
+#endif
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_FILEOBJECT_H
+#  include  "cpython/fileobject.h"
+#  undef Py_CPYTHON_FILEOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FILEOBJECT_H */
diff --git a/marketing/include/fileutils.h b/marketing/include/fileutils.h
new file mode 100644
index 0000000000000000000000000000000000000000..12bd071c49c04a514978a402067051f8461a4cbf
--- /dev/null
+++ b/marketing/include/fileutils.h
@@ -0,0 +1,30 @@
+#ifndef Py_FILEUTILS_H
+#define Py_FILEUTILS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_FUNC(wchar_t *) Py_DecodeLocale(
+    const char *arg,
+    size_t *size);
+
+PyAPI_FUNC(char*) Py_EncodeLocale(
+    const wchar_t *text,
+    size_t *error_pos);
+
+PyAPI_FUNC(char*) _Py_EncodeLocaleRaw(
+    const wchar_t *text,
+    size_t *error_pos);
+#endif
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_FILEUTILS_H
+#  include  "cpython/fileutils.h"
+#  undef Py_CPYTHON_FILEUTILS_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FILEUTILS_H */
diff --git a/marketing/include/floatobject.h b/marketing/include/floatobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..e994aa8f29da484a1e4660c28d782d2324b93145
--- /dev/null
+++ b/marketing/include/floatobject.h
@@ -0,0 +1,118 @@
+
+/* Float object interface */
+
+/*
+PyFloatObject represents a (double precision) floating point number.
+*/
+
+#ifndef Py_FLOATOBJECT_H
+#define Py_FLOATOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+typedef struct {
+    PyObject_HEAD
+    double ob_fval;
+} PyFloatObject;
+#endif
+
+PyAPI_DATA(PyTypeObject) PyFloat_Type;
+
+#define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type)
+#define PyFloat_CheckExact(op) Py_IS_TYPE(op, &PyFloat_Type)
+
+#ifdef Py_NAN
+#define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN)
+#endif
+
+#define Py_RETURN_INF(sign) do                     \
+    if (copysign(1., sign) == 1.) {                \
+        return PyFloat_FromDouble(Py_HUGE_VAL);    \
+    } else {                        \
+        return PyFloat_FromDouble(-Py_HUGE_VAL);   \
+    } while(0)
+
+PyAPI_FUNC(double) PyFloat_GetMax(void);
+PyAPI_FUNC(double) PyFloat_GetMin(void);
+PyAPI_FUNC(PyObject *) PyFloat_GetInfo(void);
+
+/* Return Python float from string PyObject. */
+PyAPI_FUNC(PyObject *) PyFloat_FromString(PyObject*);
+
+/* Return Python float from C double. */
+PyAPI_FUNC(PyObject *) PyFloat_FromDouble(double);
+
+/* Extract C double from Python float.  The macro version trades safety for
+   speed. */
+PyAPI_FUNC(double) PyFloat_AsDouble(PyObject *);
+#ifndef Py_LIMITED_API
+#define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval)
+#endif
+
+#ifndef Py_LIMITED_API
+/* _PyFloat_{Pack,Unpack}{4,8}
+ *
+ * The struct and pickle (at least) modules need an efficient platform-
+ * independent way to store floating-point values as byte strings.
+ * The Pack routines produce a string from a C double, and the Unpack
+ * routines produce a C double from such a string.  The suffix (4 or 8)
+ * specifies the number of bytes in the string.
+ *
+ * On platforms that appear to use (see _PyFloat_Init()) IEEE-754 formats
+ * these functions work by copying bits.  On other platforms, the formats the
+ * 4- byte format is identical to the IEEE-754 single precision format, and
+ * the 8-byte format to the IEEE-754 double precision format, although the
+ * packing of INFs and NaNs (if such things exist on the platform) isn't
+ * handled correctly, and attempting to unpack a string containing an IEEE
+ * INF or NaN will raise an exception.
+ *
+ * On non-IEEE platforms with more precision, or larger dynamic range, than
+ * 754 supports, not all values can be packed; on non-IEEE platforms with less
+ * precision, or smaller dynamic range, not all values can be unpacked.  What
+ * happens in such cases is partly accidental (alas).
+ */
+
+/* The pack routines write 2, 4 or 8 bytes, starting at p.  le is a bool
+ * argument, true if you want the string in little-endian format (exponent
+ * last, at p+1, p+3 or p+7), false if you want big-endian format (exponent
+ * first, at p).
+ * Return value:  0 if all is OK, -1 if error (and an exception is
+ * set, most likely OverflowError).
+ * There are two problems on non-IEEE platforms:
+ * 1):  What this does is undefined if x is a NaN or infinity.
+ * 2):  -0.0 and +0.0 produce the same string.
+ */
+PyAPI_FUNC(int) _PyFloat_Pack2(double x, unsigned char *p, int le);
+PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le);
+PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le);
+
+/* The unpack routines read 2, 4 or 8 bytes, starting at p.  le is a bool
+ * argument, true if the string is in little-endian format (exponent
+ * last, at p+1, p+3 or p+7), false if big-endian (exponent first, at p).
+ * Return value:  The unpacked double.  On error, this is -1.0 and
+ * PyErr_Occurred() is true (and an exception is set, most likely
+ * OverflowError).  Note that on a non-IEEE platform this will refuse
+ * to unpack a string that represents a NaN or infinity.
+ */
+PyAPI_FUNC(double) _PyFloat_Unpack2(const unsigned char *p, int le);
+PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le);
+PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le);
+
+PyAPI_FUNC(void) _PyFloat_DebugMallocStats(FILE* out);
+
+/* Format the object based on the format_spec, as defined in PEP 3101
+   (Advanced String Formatting). */
+PyAPI_FUNC(int) _PyFloat_FormatAdvancedWriter(
+    _PyUnicodeWriter *writer,
+    PyObject *obj,
+    PyObject *format_spec,
+    Py_ssize_t start,
+    Py_ssize_t end);
+#endif /* Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FLOATOBJECT_H */
diff --git a/marketing/include/frameobject.h b/marketing/include/frameobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..c118af1201a4c854ab899e17ca9148ae21a72991
--- /dev/null
+++ b/marketing/include/frameobject.h
@@ -0,0 +1,20 @@
+/* Frame object interface */
+
+#ifndef Py_FRAMEOBJECT_H
+#define Py_FRAMEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "pyframe.h"
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_FRAMEOBJECT_H
+#  include  "cpython/frameobject.h"
+#  undef Py_CPYTHON_FRAMEOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FRAMEOBJECT_H */
diff --git a/marketing/include/funcobject.h b/marketing/include/funcobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5cc9d261a314e61005fb82889e53f699936d74a
--- /dev/null
+++ b/marketing/include/funcobject.h
@@ -0,0 +1,98 @@
+
+/* Function object interface */
+#ifndef Py_LIMITED_API
+#ifndef Py_FUNCOBJECT_H
+#define Py_FUNCOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Function objects and code objects should not be confused with each other:
+ *
+ * Function objects are created by the execution of the 'def' statement.
+ * They reference a code object in their __code__ attribute, which is a
+ * purely syntactic object, i.e. nothing more than a compiled version of some
+ * source code lines.  There is one code object per source code "fragment",
+ * but each code object can be referenced by zero or many function objects
+ * depending only on how many times the 'def' statement in the source was
+ * executed so far.
+ */
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *func_code;        /* A code object, the __code__ attribute */
+    PyObject *func_globals;     /* A dictionary (other mappings won't do) */
+    PyObject *func_defaults;    /* NULL or a tuple */
+    PyObject *func_kwdefaults;  /* NULL or a dict */
+    PyObject *func_closure;     /* NULL or a tuple of cell objects */
+    PyObject *func_doc;         /* The __doc__ attribute, can be anything */
+    PyObject *func_name;        /* The __name__ attribute, a string object */
+    PyObject *func_dict;        /* The __dict__ attribute, a dict or NULL */
+    PyObject *func_weakreflist; /* List of weak references */
+    PyObject *func_module;      /* The __module__ attribute, can be anything */
+    PyObject *func_annotations; /* Annotations, a dict or NULL */
+    PyObject *func_qualname;    /* The qualified name */
+    vectorcallfunc vectorcall;
+
+    /* Invariant:
+     *     func_closure contains the bindings for func_code->co_freevars, so
+     *     PyTuple_Size(func_closure) == PyCode_GetNumFree(func_code)
+     *     (func_closure may be NULL if PyCode_GetNumFree(func_code) == 0).
+     */
+} PyFunctionObject;
+
+PyAPI_DATA(PyTypeObject) PyFunction_Type;
+
+#define PyFunction_Check(op) Py_IS_TYPE(op, &PyFunction_Type)
+
+PyAPI_FUNC(PyObject *) PyFunction_New(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_NewWithQualName(PyObject *, PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetCode(PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetGlobals(PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetModule(PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetDefaults(PyObject *);
+PyAPI_FUNC(int) PyFunction_SetDefaults(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetKwDefaults(PyObject *);
+PyAPI_FUNC(int) PyFunction_SetKwDefaults(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetClosure(PyObject *);
+PyAPI_FUNC(int) PyFunction_SetClosure(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetAnnotations(PyObject *);
+PyAPI_FUNC(int) PyFunction_SetAnnotations(PyObject *, PyObject *);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _PyFunction_Vectorcall(
+    PyObject *func,
+    PyObject *const *stack,
+    size_t nargsf,
+    PyObject *kwnames);
+#endif
+
+/* Macros for direct access to these values. Type checks are *not*
+   done, so use with care. */
+#define PyFunction_GET_CODE(func) \
+        (((PyFunctionObject *)func) -> func_code)
+#define PyFunction_GET_GLOBALS(func) \
+        (((PyFunctionObject *)func) -> func_globals)
+#define PyFunction_GET_MODULE(func) \
+        (((PyFunctionObject *)func) -> func_module)
+#define PyFunction_GET_DEFAULTS(func) \
+        (((PyFunctionObject *)func) -> func_defaults)
+#define PyFunction_GET_KW_DEFAULTS(func) \
+        (((PyFunctionObject *)func) -> func_kwdefaults)
+#define PyFunction_GET_CLOSURE(func) \
+        (((PyFunctionObject *)func) -> func_closure)
+#define PyFunction_GET_ANNOTATIONS(func) \
+        (((PyFunctionObject *)func) -> func_annotations)
+
+/* The classmethod and staticmethod types lives here, too */
+PyAPI_DATA(PyTypeObject) PyClassMethod_Type;
+PyAPI_DATA(PyTypeObject) PyStaticMethod_Type;
+
+PyAPI_FUNC(PyObject *) PyClassMethod_New(PyObject *);
+PyAPI_FUNC(PyObject *) PyStaticMethod_New(PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FUNCOBJECT_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/genericaliasobject.h b/marketing/include/genericaliasobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf002976b27cd7712ee80bf348f55c5c562bc12d
--- /dev/null
+++ b/marketing/include/genericaliasobject.h
@@ -0,0 +1,14 @@
+// Implementation of PEP 585: support list[int] etc.
+#ifndef Py_GENERICALIASOBJECT_H
+#define Py_GENERICALIASOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(PyObject *) Py_GenericAlias(PyObject *, PyObject *);
+PyAPI_DATA(PyTypeObject) Py_GenericAliasType;
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GENERICALIASOBJECT_H */
diff --git a/marketing/include/genobject.h b/marketing/include/genobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ffd15646f084e2aae375e2638d5abe7325e92f3
--- /dev/null
+++ b/marketing/include/genobject.h
@@ -0,0 +1,102 @@
+
+/* Generator object interface */
+
+#ifndef Py_LIMITED_API
+#ifndef Py_GENOBJECT_H
+#define Py_GENOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "pystate.h"   /* _PyErr_StackItem */
+
+/* _PyGenObject_HEAD defines the initial segment of generator
+   and coroutine objects. */
+#define _PyGenObject_HEAD(prefix)                                           \
+    PyObject_HEAD                                                           \
+    /* Note: gi_frame can be NULL if the generator is "finished" */         \
+    PyFrameObject *prefix##_frame;                                          \
+    /* True if generator is being executed. */                              \
+    char prefix##_running;                                                  \
+    /* The code object backing the generator */                             \
+    PyObject *prefix##_code;                                                \
+    /* List of weak reference. */                                           \
+    PyObject *prefix##_weakreflist;                                         \
+    /* Name of the generator. */                                            \
+    PyObject *prefix##_name;                                                \
+    /* Qualified name of the generator. */                                  \
+    PyObject *prefix##_qualname;                                            \
+    _PyErr_StackItem prefix##_exc_state;
+
+typedef struct {
+    /* The gi_ prefix is intended to remind of generator-iterator. */
+    _PyGenObject_HEAD(gi)
+} PyGenObject;
+
+PyAPI_DATA(PyTypeObject) PyGen_Type;
+
+#define PyGen_Check(op) PyObject_TypeCheck(op, &PyGen_Type)
+#define PyGen_CheckExact(op) Py_IS_TYPE(op, &PyGen_Type)
+
+PyAPI_FUNC(PyObject *) PyGen_New(PyFrameObject *);
+PyAPI_FUNC(PyObject *) PyGen_NewWithQualName(PyFrameObject *,
+    PyObject *name, PyObject *qualname);
+PyAPI_FUNC(int) _PyGen_SetStopIterationValue(PyObject *);
+PyAPI_FUNC(int) _PyGen_FetchStopIterationValue(PyObject **);
+PyAPI_FUNC(PyObject *) _PyGen_Send(PyGenObject *, PyObject *);
+PyObject *_PyGen_yf(PyGenObject *);
+PyAPI_FUNC(void) _PyGen_Finalize(PyObject *self);
+
+#ifndef Py_LIMITED_API
+typedef struct {
+    _PyGenObject_HEAD(cr)
+    PyObject *cr_origin;
+} PyCoroObject;
+
+PyAPI_DATA(PyTypeObject) PyCoro_Type;
+PyAPI_DATA(PyTypeObject) _PyCoroWrapper_Type;
+
+#define PyCoro_CheckExact(op) Py_IS_TYPE(op, &PyCoro_Type)
+PyObject *_PyCoro_GetAwaitableIter(PyObject *o);
+PyAPI_FUNC(PyObject *) PyCoro_New(PyFrameObject *,
+    PyObject *name, PyObject *qualname);
+
+/* Asynchronous Generators */
+
+typedef struct {
+    _PyGenObject_HEAD(ag)
+    PyObject *ag_finalizer;
+
+    /* Flag is set to 1 when hooks set up by sys.set_asyncgen_hooks
+       were called on the generator, to avoid calling them more
+       than once. */
+    int ag_hooks_inited;
+
+    /* Flag is set to 1 when aclose() is called for the first time, or
+       when a StopAsyncIteration exception is raised. */
+    int ag_closed;
+
+    int ag_running_async;
+} PyAsyncGenObject;
+
+PyAPI_DATA(PyTypeObject) PyAsyncGen_Type;
+PyAPI_DATA(PyTypeObject) _PyAsyncGenASend_Type;
+PyAPI_DATA(PyTypeObject) _PyAsyncGenWrappedValue_Type;
+PyAPI_DATA(PyTypeObject) _PyAsyncGenAThrow_Type;
+
+PyAPI_FUNC(PyObject *) PyAsyncGen_New(PyFrameObject *,
+    PyObject *name, PyObject *qualname);
+
+#define PyAsyncGen_CheckExact(op) Py_IS_TYPE(op, &PyAsyncGen_Type)
+
+PyObject *_PyAsyncGenValueWrapperNew(PyObject *);
+
+#endif
+
+#undef _PyGenObject_HEAD
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GENOBJECT_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/graminit.h b/marketing/include/graminit.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1027b7a743f2430e111751ed7a8bd484186b5cb
--- /dev/null
+++ b/marketing/include/graminit.h
@@ -0,0 +1,94 @@
+/* Generated by Parser/pgen */
+
+#define single_input 256
+#define file_input 257
+#define eval_input 258
+#define decorator 259
+#define decorators 260
+#define decorated 261
+#define async_funcdef 262
+#define funcdef 263
+#define parameters 264
+#define typedargslist 265
+#define tfpdef 266
+#define varargslist 267
+#define vfpdef 268
+#define stmt 269
+#define simple_stmt 270
+#define small_stmt 271
+#define expr_stmt 272
+#define annassign 273
+#define testlist_star_expr 274
+#define augassign 275
+#define del_stmt 276
+#define pass_stmt 277
+#define flow_stmt 278
+#define break_stmt 279
+#define continue_stmt 280
+#define return_stmt 281
+#define yield_stmt 282
+#define raise_stmt 283
+#define import_stmt 284
+#define import_name 285
+#define import_from 286
+#define import_as_name 287
+#define dotted_as_name 288
+#define import_as_names 289
+#define dotted_as_names 290
+#define dotted_name 291
+#define global_stmt 292
+#define nonlocal_stmt 293
+#define assert_stmt 294
+#define compound_stmt 295
+#define async_stmt 296
+#define if_stmt 297
+#define while_stmt 298
+#define for_stmt 299
+#define try_stmt 300
+#define with_stmt 301
+#define with_item 302
+#define except_clause 303
+#define suite 304
+#define namedexpr_test 305
+#define test 306
+#define test_nocond 307
+#define lambdef 308
+#define lambdef_nocond 309
+#define or_test 310
+#define and_test 311
+#define not_test 312
+#define comparison 313
+#define comp_op 314
+#define star_expr 315
+#define expr 316
+#define xor_expr 317
+#define and_expr 318
+#define shift_expr 319
+#define arith_expr 320
+#define term 321
+#define factor 322
+#define power 323
+#define atom_expr 324
+#define atom 325
+#define testlist_comp 326
+#define trailer 327
+#define subscriptlist 328
+#define subscript 329
+#define sliceop 330
+#define exprlist 331
+#define testlist 332
+#define dictorsetmaker 333
+#define classdef 334
+#define arglist 335
+#define argument 336
+#define comp_iter 337
+#define sync_comp_for 338
+#define comp_for 339
+#define comp_if 340
+#define encoding_decl 341
+#define yield_expr 342
+#define yield_arg 343
+#define func_body_suite 344
+#define func_type_input 345
+#define func_type 346
+#define typelist 347
diff --git a/marketing/include/grammar.h b/marketing/include/grammar.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b66b1e9b97451b1291fcd6eb094b60fd2019b34
--- /dev/null
+++ b/marketing/include/grammar.h
@@ -0,0 +1,77 @@
+
+/* Grammar interface */
+
+#ifndef Py_GRAMMAR_H
+#define Py_GRAMMAR_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "bitset.h" /* Sigh... */
+
+/* A label of an arc */
+
+typedef struct {
+    int          lb_type;
+    const char  *lb_str;
+} label;
+
+#define EMPTY 0         /* Label number 0 is by definition the empty label */
+
+/* A list of labels */
+
+typedef struct {
+    int          ll_nlabels;
+    const label *ll_label;
+} labellist;
+
+/* An arc from one state to another */
+
+typedef struct {
+    short       a_lbl;          /* Label of this arc */
+    short       a_arrow;        /* State where this arc goes to */
+} arc;
+
+/* A state in a DFA */
+
+typedef struct {
+    int          s_narcs;
+    const arc   *s_arc;         /* Array of arcs */
+
+    /* Optional accelerators */
+    int          s_lower;       /* Lowest label index */
+    int          s_upper;       /* Highest label index */
+    int         *s_accel;       /* Accelerator */
+    int          s_accept;      /* Nonzero for accepting state */
+} state;
+
+/* A DFA */
+
+typedef struct {
+    int          d_type;        /* Non-terminal this represents */
+    char        *d_name;        /* For printing */
+    int          d_nstates;
+    state       *d_state;       /* Array of states */
+    bitset       d_first;
+} dfa;
+
+/* A grammar */
+
+typedef struct {
+    int          g_ndfas;
+    const dfa   *g_dfa;         /* Array of DFAs */
+    const labellist g_ll;
+    int          g_start;       /* Start symbol of the grammar */
+    int          g_accel;       /* Set if accelerators present */
+} grammar;
+
+/* FUNCTIONS */
+const dfa *PyGrammar_FindDFA(grammar *g, int type);
+const char *PyGrammar_LabelRepr(label *lb);
+void PyGrammar_AddAccelerators(grammar *g);
+void PyGrammar_RemoveAccelerators(grammar *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GRAMMAR_H */
diff --git a/marketing/include/import.h b/marketing/include/import.h
new file mode 100644
index 0000000000000000000000000000000000000000..aeef3efd0bcee8e20183c91c41c1cda50ff7888f
--- /dev/null
+++ b/marketing/include/import.h
@@ -0,0 +1,98 @@
+/* Module definition and import interface */
+
+#ifndef Py_IMPORT_H
+#define Py_IMPORT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(long) PyImport_GetMagicNumber(void);
+PyAPI_FUNC(const char *) PyImport_GetMagicTag(void);
+PyAPI_FUNC(PyObject *) PyImport_ExecCodeModule(
+    const char *name,           /* UTF-8 encoded string */
+    PyObject *co
+    );
+PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleEx(
+    const char *name,           /* UTF-8 encoded string */
+    PyObject *co,
+    const char *pathname        /* decoded from the filesystem encoding */
+    );
+PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleWithPathnames(
+    const char *name,           /* UTF-8 encoded string */
+    PyObject *co,
+    const char *pathname,       /* decoded from the filesystem encoding */
+    const char *cpathname       /* decoded from the filesystem encoding */
+    );
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject *) PyImport_ExecCodeModuleObject(
+    PyObject *name,
+    PyObject *co,
+    PyObject *pathname,
+    PyObject *cpathname
+    );
+#endif
+PyAPI_FUNC(PyObject *) PyImport_GetModuleDict(void);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
+PyAPI_FUNC(PyObject *) PyImport_GetModule(PyObject *name);
+#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject *) PyImport_AddModuleObject(
+    PyObject *name
+    );
+#endif
+PyAPI_FUNC(PyObject *) PyImport_AddModule(
+    const char *name            /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(PyObject *) PyImport_ImportModule(
+    const char *name            /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(PyObject *) PyImport_ImportModuleNoBlock(
+    const char *name            /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(PyObject *) PyImport_ImportModuleLevel(
+    const char *name,           /* UTF-8 encoded string */
+    PyObject *globals,
+    PyObject *locals,
+    PyObject *fromlist,
+    int level
+    );
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_FUNC(PyObject *) PyImport_ImportModuleLevelObject(
+    PyObject *name,
+    PyObject *globals,
+    PyObject *locals,
+    PyObject *fromlist,
+    int level
+    );
+#endif
+
+#define PyImport_ImportModuleEx(n, g, l, f) \
+    PyImport_ImportModuleLevel(n, g, l, f, 0)
+
+PyAPI_FUNC(PyObject *) PyImport_GetImporter(PyObject *path);
+PyAPI_FUNC(PyObject *) PyImport_Import(PyObject *name);
+PyAPI_FUNC(PyObject *) PyImport_ReloadModule(PyObject *m);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(int) PyImport_ImportFrozenModuleObject(
+    PyObject *name
+    );
+#endif
+PyAPI_FUNC(int) PyImport_ImportFrozenModule(
+    const char *name            /* UTF-8 encoded string */
+    );
+
+PyAPI_FUNC(int) PyImport_AppendInittab(
+    const char *name,           /* ASCII encoded string */
+    PyObject* (*initfunc)(void)
+    );
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_IMPORT_H
+#  include  "cpython/import.h"
+#  undef Py_CPYTHON_IMPORT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_IMPORT_H */
diff --git a/marketing/include/internal/pegen_interface.h b/marketing/include/internal/pegen_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee4c77ec006760cb14c34340fc3a5a5248d51735
--- /dev/null
+++ b/marketing/include/internal/pegen_interface.h
@@ -0,0 +1,46 @@
+#ifndef Py_PEGENINTERFACE
+#define Py_PEGENINTERFACE
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "Python.h"
+#include "Python-ast.h"
+
+PyAPI_FUNC(mod_ty) PyPegen_ASTFromString(
+    const char *str,
+    const char *filename,
+    int mode,
+    PyCompilerFlags *flags,
+    PyArena *arena);
+PyAPI_FUNC(mod_ty) PyPegen_ASTFromStringObject(
+    const char *str,
+    PyObject* filename,
+    int mode,
+    PyCompilerFlags *flags,
+    PyArena *arena);
+PyAPI_FUNC(mod_ty) PyPegen_ASTFromFileObject(
+    FILE *fp,
+    PyObject *filename_ob,
+    int mode,
+    const char *enc,
+    const char *ps1,
+    const char *ps2,
+    PyCompilerFlags *flags,
+    int *errcode,
+    PyArena *arena);
+PyAPI_FUNC(mod_ty) PyPegen_ASTFromFilename(
+    const char *filename,
+    int mode,
+    PyCompilerFlags *flags,
+    PyArena *arena);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PEGENINTERFACE*/
diff --git a/marketing/include/internal/pycore_abstract.h b/marketing/include/internal/pycore_abstract.h
new file mode 100644
index 0000000000000000000000000000000000000000..b791bf24321991508ac9eb0186323c3d1ce4dc3b
--- /dev/null
+++ b/marketing/include/internal/pycore_abstract.h
@@ -0,0 +1,22 @@
+#ifndef Py_INTERNAL_ABSTRACT_H
+#define Py_INTERNAL_ABSTRACT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+// Fast inlined version of PyIndex_Check()
+static inline int
+_PyIndex_Check(PyObject *obj)
+{
+    PyNumberMethods *tp_as_number = Py_TYPE(obj)->tp_as_number;
+    return (tp_as_number != NULL && tp_as_number->nb_index != NULL);
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_ABSTRACT_H */
diff --git a/marketing/include/internal/pycore_accu.h b/marketing/include/internal/pycore_accu.h
new file mode 100644
index 0000000000000000000000000000000000000000..d346222e4dd0c9789f01ca1b97c96124bc01abae
--- /dev/null
+++ b/marketing/include/internal/pycore_accu.h
@@ -0,0 +1,39 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_INTERNAL_ACCU_H
+#define Py_INTERNAL_ACCU_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*** This is a private API for use by the interpreter and the stdlib.
+ *** Its definition may be changed or removed at any moment.
+ ***/
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/*
+ * A two-level accumulator of unicode objects that avoids both the overhead
+ * of keeping a huge number of small separate objects, and the quadratic
+ * behaviour of using a naive repeated concatenation scheme.
+ */
+
+#undef small /* defined by some Windows headers */
+
+typedef struct {
+    PyObject *large;  /* A list of previously accumulated large strings */
+    PyObject *small;  /* Pending small strings */
+} _PyAccu;
+
+PyAPI_FUNC(int) _PyAccu_Init(_PyAccu *acc);
+PyAPI_FUNC(int) _PyAccu_Accumulate(_PyAccu *acc, PyObject *unicode);
+PyAPI_FUNC(PyObject *) _PyAccu_FinishAsList(_PyAccu *acc);
+PyAPI_FUNC(PyObject *) _PyAccu_Finish(_PyAccu *acc);
+PyAPI_FUNC(void) _PyAccu_Destroy(_PyAccu *acc);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_ACCU_H */
+#endif /* !Py_LIMITED_API */
diff --git a/marketing/include/internal/pycore_atomic.h b/marketing/include/internal/pycore_atomic.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d5c5621677eb3706e9fe09010dcf7ee1f9a701f
--- /dev/null
+++ b/marketing/include/internal/pycore_atomic.h
@@ -0,0 +1,557 @@
+#ifndef Py_ATOMIC_H
+#define Py_ATOMIC_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "dynamic_annotations.h"   /* _Py_ANNOTATE_MEMORY_ORDER */
+#include "pyconfig.h"
+
+#if defined(HAVE_STD_ATOMIC)
+#include 
+#endif
+
+
+#if defined(_MSC_VER)
+#include 
+#if defined(_M_IX86) || defined(_M_X64)
+#  include 
+#endif
+#endif
+
+/* This is modeled after the atomics interface from C1x, according to
+ * the draft at
+ * http://www.open-std.org/JTC1/SC22/wg14/www/docs/n1425.pdf.
+ * Operations and types are named the same except with a _Py_ prefix
+ * and have the same semantics.
+ *
+ * Beware, the implementations here are deep magic.
+ */
+
+#if defined(HAVE_STD_ATOMIC)
+
+typedef enum _Py_memory_order {
+    _Py_memory_order_relaxed = memory_order_relaxed,
+    _Py_memory_order_acquire = memory_order_acquire,
+    _Py_memory_order_release = memory_order_release,
+    _Py_memory_order_acq_rel = memory_order_acq_rel,
+    _Py_memory_order_seq_cst = memory_order_seq_cst
+} _Py_memory_order;
+
+typedef struct _Py_atomic_address {
+    atomic_uintptr_t _value;
+} _Py_atomic_address;
+
+typedef struct _Py_atomic_int {
+    atomic_int _value;
+} _Py_atomic_int;
+
+#define _Py_atomic_signal_fence(/*memory_order*/ ORDER) \
+    atomic_signal_fence(ORDER)
+
+#define _Py_atomic_thread_fence(/*memory_order*/ ORDER) \
+    atomic_thread_fence(ORDER)
+
+#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
+    atomic_store_explicit(&((ATOMIC_VAL)->_value), NEW_VAL, ORDER)
+
+#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
+    atomic_load_explicit(&((ATOMIC_VAL)->_value), ORDER)
+
+/* Use builtin atomic operations in GCC >= 4.7 */
+#elif defined(HAVE_BUILTIN_ATOMIC)
+
+typedef enum _Py_memory_order {
+    _Py_memory_order_relaxed = __ATOMIC_RELAXED,
+    _Py_memory_order_acquire = __ATOMIC_ACQUIRE,
+    _Py_memory_order_release = __ATOMIC_RELEASE,
+    _Py_memory_order_acq_rel = __ATOMIC_ACQ_REL,
+    _Py_memory_order_seq_cst = __ATOMIC_SEQ_CST
+} _Py_memory_order;
+
+typedef struct _Py_atomic_address {
+    uintptr_t _value;
+} _Py_atomic_address;
+
+typedef struct _Py_atomic_int {
+    int _value;
+} _Py_atomic_int;
+
+#define _Py_atomic_signal_fence(/*memory_order*/ ORDER) \
+    __atomic_signal_fence(ORDER)
+
+#define _Py_atomic_thread_fence(/*memory_order*/ ORDER) \
+    __atomic_thread_fence(ORDER)
+
+#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
+    (assert((ORDER) == __ATOMIC_RELAXED                       \
+            || (ORDER) == __ATOMIC_SEQ_CST                    \
+            || (ORDER) == __ATOMIC_RELEASE),                  \
+     __atomic_store_n(&((ATOMIC_VAL)->_value), NEW_VAL, ORDER))
+
+#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER)           \
+    (assert((ORDER) == __ATOMIC_RELAXED                       \
+            || (ORDER) == __ATOMIC_SEQ_CST                    \
+            || (ORDER) == __ATOMIC_ACQUIRE                    \
+            || (ORDER) == __ATOMIC_CONSUME),                  \
+     __atomic_load_n(&((ATOMIC_VAL)->_value), ORDER))
+
+/* Only support GCC (for expression statements) and x86 (for simple
+ * atomic semantics) and MSVC x86/x64/ARM */
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__amd64))
+typedef enum _Py_memory_order {
+    _Py_memory_order_relaxed,
+    _Py_memory_order_acquire,
+    _Py_memory_order_release,
+    _Py_memory_order_acq_rel,
+    _Py_memory_order_seq_cst
+} _Py_memory_order;
+
+typedef struct _Py_atomic_address {
+    uintptr_t _value;
+} _Py_atomic_address;
+
+typedef struct _Py_atomic_int {
+    int _value;
+} _Py_atomic_int;
+
+
+static __inline__ void
+_Py_atomic_signal_fence(_Py_memory_order order)
+{
+    if (order != _Py_memory_order_relaxed)
+        __asm__ volatile("":::"memory");
+}
+
+static __inline__ void
+_Py_atomic_thread_fence(_Py_memory_order order)
+{
+    if (order != _Py_memory_order_relaxed)
+        __asm__ volatile("mfence":::"memory");
+}
+
+/* Tell the race checker about this operation's effects. */
+static __inline__ void
+_Py_ANNOTATE_MEMORY_ORDER(const volatile void *address, _Py_memory_order order)
+{
+    (void)address;              /* shut up -Wunused-parameter */
+    switch(order) {
+    case _Py_memory_order_release:
+    case _Py_memory_order_acq_rel:
+    case _Py_memory_order_seq_cst:
+        _Py_ANNOTATE_HAPPENS_BEFORE(address);
+        break;
+    case _Py_memory_order_relaxed:
+    case _Py_memory_order_acquire:
+        break;
+    }
+    switch(order) {
+    case _Py_memory_order_acquire:
+    case _Py_memory_order_acq_rel:
+    case _Py_memory_order_seq_cst:
+        _Py_ANNOTATE_HAPPENS_AFTER(address);
+        break;
+    case _Py_memory_order_relaxed:
+    case _Py_memory_order_release:
+        break;
+    }
+}
+
+#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
+    __extension__ ({ \
+        __typeof__(ATOMIC_VAL) atomic_val = ATOMIC_VAL; \
+        __typeof__(atomic_val->_value) new_val = NEW_VAL;\
+        volatile __typeof__(new_val) *volatile_data = &atomic_val->_value; \
+        _Py_memory_order order = ORDER; \
+        _Py_ANNOTATE_MEMORY_ORDER(atomic_val, order); \
+        \
+        /* Perform the operation. */ \
+        _Py_ANNOTATE_IGNORE_WRITES_BEGIN(); \
+        switch(order) { \
+        case _Py_memory_order_release: \
+            _Py_atomic_signal_fence(_Py_memory_order_release); \
+            /* fallthrough */ \
+        case _Py_memory_order_relaxed: \
+            *volatile_data = new_val; \
+            break; \
+        \
+        case _Py_memory_order_acquire: \
+        case _Py_memory_order_acq_rel: \
+        case _Py_memory_order_seq_cst: \
+            __asm__ volatile("xchg %0, %1" \
+                         : "+r"(new_val) \
+                         : "m"(atomic_val->_value) \
+                         : "memory"); \
+            break; \
+        } \
+        _Py_ANNOTATE_IGNORE_WRITES_END(); \
+    })
+
+#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
+    __extension__ ({  \
+        __typeof__(ATOMIC_VAL) atomic_val = ATOMIC_VAL; \
+        __typeof__(atomic_val->_value) result; \
+        volatile __typeof__(result) *volatile_data = &atomic_val->_value; \
+        _Py_memory_order order = ORDER; \
+        _Py_ANNOTATE_MEMORY_ORDER(atomic_val, order); \
+        \
+        /* Perform the operation. */ \
+        _Py_ANNOTATE_IGNORE_READS_BEGIN(); \
+        switch(order) { \
+        case _Py_memory_order_release: \
+        case _Py_memory_order_acq_rel: \
+        case _Py_memory_order_seq_cst: \
+            /* Loads on x86 are not releases by default, so need a */ \
+            /* thread fence. */ \
+            _Py_atomic_thread_fence(_Py_memory_order_release); \
+            break; \
+        default: \
+            /* No fence */ \
+            break; \
+        } \
+        result = *volatile_data; \
+        switch(order) { \
+        case _Py_memory_order_acquire: \
+        case _Py_memory_order_acq_rel: \
+        case _Py_memory_order_seq_cst: \
+            /* Loads on x86 are automatically acquire operations so */ \
+            /* can get by with just a compiler fence. */ \
+            _Py_atomic_signal_fence(_Py_memory_order_acquire); \
+            break; \
+        default: \
+            /* No fence */ \
+            break; \
+        } \
+        _Py_ANNOTATE_IGNORE_READS_END(); \
+        result; \
+    })
+
+#elif defined(_MSC_VER)
+/*  _Interlocked* functions provide a full memory barrier and are therefore
+    enough for acq_rel and seq_cst. If the HLE variants aren't available
+    in hardware they will fall back to a full memory barrier as well.
+
+    This might affect performance but likely only in some very specific and
+    hard to meassure scenario.
+*/
+#if defined(_M_IX86) || defined(_M_X64)
+typedef enum _Py_memory_order {
+    _Py_memory_order_relaxed,
+    _Py_memory_order_acquire,
+    _Py_memory_order_release,
+    _Py_memory_order_acq_rel,
+    _Py_memory_order_seq_cst
+} _Py_memory_order;
+
+typedef struct _Py_atomic_address {
+    volatile uintptr_t _value;
+} _Py_atomic_address;
+
+typedef struct _Py_atomic_int {
+    volatile int _value;
+} _Py_atomic_int;
+
+
+#if defined(_M_X64)
+#define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) \
+    switch (ORDER) { \
+    case _Py_memory_order_acquire: \
+      _InterlockedExchange64_HLEAcquire((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \
+      break; \
+    case _Py_memory_order_release: \
+      _InterlockedExchange64_HLERelease((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \
+      break; \
+    default: \
+      _InterlockedExchange64((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \
+      break; \
+  }
+#else
+#define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) ((void)0);
+#endif
+
+#define _Py_atomic_store_32bit(ATOMIC_VAL, NEW_VAL, ORDER) \
+  switch (ORDER) { \
+  case _Py_memory_order_acquire: \
+    _InterlockedExchange_HLEAcquire((volatile long*)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \
+    break; \
+  case _Py_memory_order_release: \
+    _InterlockedExchange_HLERelease((volatile long*)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \
+    break; \
+  default: \
+    _InterlockedExchange((volatile long*)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \
+    break; \
+  }
+
+#if defined(_M_X64)
+/*  This has to be an intptr_t for now.
+    gil_created() uses -1 as a sentinel value, if this returns
+    a uintptr_t it will do an unsigned compare and crash
+*/
+inline intptr_t _Py_atomic_load_64bit_impl(volatile uintptr_t* value, int order) {
+    __int64 old;
+    switch (order) {
+    case _Py_memory_order_acquire:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange64_HLEAcquire((volatile __int64*)value, old, old) != old);
+      break;
+    }
+    case _Py_memory_order_release:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange64_HLERelease((volatile __int64*)value, old, old) != old);
+      break;
+    }
+    case _Py_memory_order_relaxed:
+      old = *value;
+      break;
+    default:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange64((volatile __int64*)value, old, old) != old);
+      break;
+    }
+    }
+    return old;
+}
+
+#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) \
+    _Py_atomic_load_64bit_impl((volatile uintptr_t*)&((ATOMIC_VAL)->_value), (ORDER))
+
+#else
+#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) ((ATOMIC_VAL)->_value)
+#endif
+
+inline int _Py_atomic_load_32bit_impl(volatile int* value, int order) {
+    long old;
+    switch (order) {
+    case _Py_memory_order_acquire:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange_HLEAcquire((volatile long*)value, old, old) != old);
+      break;
+    }
+    case _Py_memory_order_release:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange_HLERelease((volatile long*)value, old, old) != old);
+      break;
+    }
+    case _Py_memory_order_relaxed:
+      old = *value;
+      break;
+    default:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange((volatile long*)value, old, old) != old);
+      break;
+    }
+    }
+    return old;
+}
+
+#define _Py_atomic_load_32bit(ATOMIC_VAL, ORDER) \
+    _Py_atomic_load_32bit_impl((volatile int*)&((ATOMIC_VAL)->_value), (ORDER))
+
+#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
+  if (sizeof((ATOMIC_VAL)->_value) == 8) { \
+    _Py_atomic_store_64bit((ATOMIC_VAL), NEW_VAL, ORDER) } else { \
+    _Py_atomic_store_32bit((ATOMIC_VAL), NEW_VAL, ORDER) }
+
+#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
+  ( \
+    sizeof((ATOMIC_VAL)->_value) == 8 ? \
+    _Py_atomic_load_64bit((ATOMIC_VAL), ORDER) : \
+    _Py_atomic_load_32bit((ATOMIC_VAL), ORDER) \
+  )
+#elif defined(_M_ARM) || defined(_M_ARM64)
+typedef enum _Py_memory_order {
+    _Py_memory_order_relaxed,
+    _Py_memory_order_acquire,
+    _Py_memory_order_release,
+    _Py_memory_order_acq_rel,
+    _Py_memory_order_seq_cst
+} _Py_memory_order;
+
+typedef struct _Py_atomic_address {
+    volatile uintptr_t _value;
+} _Py_atomic_address;
+
+typedef struct _Py_atomic_int {
+    volatile int _value;
+} _Py_atomic_int;
+
+
+#if defined(_M_ARM64)
+#define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) \
+    switch (ORDER) { \
+    case _Py_memory_order_acquire: \
+      _InterlockedExchange64_acq((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \
+      break; \
+    case _Py_memory_order_release: \
+      _InterlockedExchange64_rel((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \
+      break; \
+    default: \
+      _InterlockedExchange64((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \
+      break; \
+  }
+#else
+#define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) ((void)0);
+#endif
+
+#define _Py_atomic_store_32bit(ATOMIC_VAL, NEW_VAL, ORDER) \
+  switch (ORDER) { \
+  case _Py_memory_order_acquire: \
+    _InterlockedExchange_acq((volatile long*)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \
+    break; \
+  case _Py_memory_order_release: \
+    _InterlockedExchange_rel((volatile long*)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \
+    break; \
+  default: \
+    _InterlockedExchange((volatile long*)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \
+    break; \
+  }
+
+#if defined(_M_ARM64)
+/*  This has to be an intptr_t for now.
+    gil_created() uses -1 as a sentinel value, if this returns
+    a uintptr_t it will do an unsigned compare and crash
+*/
+inline intptr_t _Py_atomic_load_64bit_impl(volatile uintptr_t* value, int order) {
+    uintptr_t old;
+    switch (order) {
+    case _Py_memory_order_acquire:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange64_acq(value, old, old) != old);
+      break;
+    }
+    case _Py_memory_order_release:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange64_rel(value, old, old) != old);
+      break;
+    }
+    case _Py_memory_order_relaxed:
+      old = *value;
+      break;
+    default:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange64(value, old, old) != old);
+      break;
+    }
+    }
+    return old;
+}
+
+#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) \
+    _Py_atomic_load_64bit_impl((volatile uintptr_t*)&((ATOMIC_VAL)->_value), (ORDER))
+
+#else
+#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) ((ATOMIC_VAL)->_value)
+#endif
+
+inline int _Py_atomic_load_32bit_impl(volatile int* value, int order) {
+    int old;
+    switch (order) {
+    case _Py_memory_order_acquire:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange_acq(value, old, old) != old);
+      break;
+    }
+    case _Py_memory_order_release:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange_rel(value, old, old) != old);
+      break;
+    }
+    case _Py_memory_order_relaxed:
+      old = *value;
+      break;
+    default:
+    {
+      do {
+        old = *value;
+      } while(_InterlockedCompareExchange(value, old, old) != old);
+      break;
+    }
+    }
+    return old;
+}
+
+#define _Py_atomic_load_32bit(ATOMIC_VAL, ORDER) \
+    _Py_atomic_load_32bit_impl((volatile int*)&((ATOMIC_VAL)->_value), (ORDER))
+
+#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
+  if (sizeof((ATOMIC_VAL)->_value) == 8) { \
+    _Py_atomic_store_64bit((ATOMIC_VAL), (NEW_VAL), (ORDER)) } else { \
+    _Py_atomic_store_32bit((ATOMIC_VAL), (NEW_VAL), (ORDER)) }
+
+#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
+  ( \
+    sizeof((ATOMIC_VAL)->_value) == 8 ? \
+    _Py_atomic_load_64bit((ATOMIC_VAL), (ORDER)) : \
+    _Py_atomic_load_32bit((ATOMIC_VAL), (ORDER)) \
+  )
+#endif
+#else  /* !gcc x86  !_msc_ver */
+typedef enum _Py_memory_order {
+    _Py_memory_order_relaxed,
+    _Py_memory_order_acquire,
+    _Py_memory_order_release,
+    _Py_memory_order_acq_rel,
+    _Py_memory_order_seq_cst
+} _Py_memory_order;
+
+typedef struct _Py_atomic_address {
+    uintptr_t _value;
+} _Py_atomic_address;
+
+typedef struct _Py_atomic_int {
+    int _value;
+} _Py_atomic_int;
+/* Fall back to other compilers and processors by assuming that simple
+   volatile accesses are atomic.  This is false, so people should port
+   this. */
+#define _Py_atomic_signal_fence(/*memory_order*/ ORDER) ((void)0)
+#define _Py_atomic_thread_fence(/*memory_order*/ ORDER) ((void)0)
+#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
+    ((ATOMIC_VAL)->_value = NEW_VAL)
+#define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \
+    ((ATOMIC_VAL)->_value)
+#endif
+
+/* Standardized shortcuts. */
+#define _Py_atomic_store(ATOMIC_VAL, NEW_VAL) \
+    _Py_atomic_store_explicit((ATOMIC_VAL), (NEW_VAL), _Py_memory_order_seq_cst)
+#define _Py_atomic_load(ATOMIC_VAL) \
+    _Py_atomic_load_explicit((ATOMIC_VAL), _Py_memory_order_seq_cst)
+
+/* Python-local extensions */
+
+#define _Py_atomic_store_relaxed(ATOMIC_VAL, NEW_VAL) \
+    _Py_atomic_store_explicit((ATOMIC_VAL), (NEW_VAL), _Py_memory_order_relaxed)
+#define _Py_atomic_load_relaxed(ATOMIC_VAL) \
+    _Py_atomic_load_explicit((ATOMIC_VAL), _Py_memory_order_relaxed)
+
+#ifdef __cplusplus
+}
+#endif
+#endif  /* Py_ATOMIC_H */
diff --git a/marketing/include/internal/pycore_bytes_methods.h b/marketing/include/internal/pycore_bytes_methods.h
new file mode 100644
index 0000000000000000000000000000000000000000..11e8ab20e91367ced72b6c7660201f77a0230cd1
--- /dev/null
+++ b/marketing/include/internal/pycore_bytes_methods.h
@@ -0,0 +1,73 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_BYTES_CTYPE_H
+#define Py_BYTES_CTYPE_H
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/*
+ * The internal implementation behind PyBytes (bytes) and PyByteArray (bytearray)
+ * methods of the given names, they operate on ASCII byte strings.
+ */
+extern PyObject* _Py_bytes_isspace(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_isalpha(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_isalnum(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_isascii(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_isdigit(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_islower(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_isupper(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_istitle(const char *cptr, Py_ssize_t len);
+
+/* These store their len sized answer in the given preallocated *result arg. */
+extern void _Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len);
+extern void _Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len);
+extern void _Py_bytes_title(char *result, const char *s, Py_ssize_t len);
+extern void _Py_bytes_capitalize(char *result, const char *s, Py_ssize_t len);
+extern void _Py_bytes_swapcase(char *result, const char *s, Py_ssize_t len);
+
+extern PyObject *_Py_bytes_find(const char *str, Py_ssize_t len, PyObject *args);
+extern PyObject *_Py_bytes_index(const char *str, Py_ssize_t len, PyObject *args);
+extern PyObject *_Py_bytes_rfind(const char *str, Py_ssize_t len, PyObject *args);
+extern PyObject *_Py_bytes_rindex(const char *str, Py_ssize_t len, PyObject *args);
+extern PyObject *_Py_bytes_count(const char *str, Py_ssize_t len, PyObject *args);
+extern int _Py_bytes_contains(const char *str, Py_ssize_t len, PyObject *arg);
+extern PyObject *_Py_bytes_startswith(const char *str, Py_ssize_t len, PyObject *args);
+extern PyObject *_Py_bytes_endswith(const char *str, Py_ssize_t len, PyObject *args);
+
+/* The maketrans() static method. */
+extern PyObject* _Py_bytes_maketrans(Py_buffer *frm, Py_buffer *to);
+
+/* Shared __doc__ strings. */
+extern const char _Py_isspace__doc__[];
+extern const char _Py_isalpha__doc__[];
+extern const char _Py_isalnum__doc__[];
+extern const char _Py_isascii__doc__[];
+extern const char _Py_isdigit__doc__[];
+extern const char _Py_islower__doc__[];
+extern const char _Py_isupper__doc__[];
+extern const char _Py_istitle__doc__[];
+extern const char _Py_lower__doc__[];
+extern const char _Py_upper__doc__[];
+extern const char _Py_title__doc__[];
+extern const char _Py_capitalize__doc__[];
+extern const char _Py_swapcase__doc__[];
+extern const char _Py_count__doc__[];
+extern const char _Py_find__doc__[];
+extern const char _Py_index__doc__[];
+extern const char _Py_rfind__doc__[];
+extern const char _Py_rindex__doc__[];
+extern const char _Py_startswith__doc__[];
+extern const char _Py_endswith__doc__[];
+extern const char _Py_maketrans__doc__[];
+extern const char _Py_expandtabs__doc__[];
+extern const char _Py_ljust__doc__[];
+extern const char _Py_rjust__doc__[];
+extern const char _Py_center__doc__[];
+extern const char _Py_zfill__doc__[];
+
+/* this is needed because some docs are shared from the .o, not static */
+#define PyDoc_STRVAR_shared(name,str) const char name[] = PyDoc_STR(str)
+
+#endif /* !Py_BYTES_CTYPE_H */
+#endif /* !Py_LIMITED_API */
diff --git a/marketing/include/internal/pycore_byteswap.h b/marketing/include/internal/pycore_byteswap.h
new file mode 100644
index 0000000000000000000000000000000000000000..2b20fc6c7d3136bcf90cba28de95e61a9de10054
--- /dev/null
+++ b/marketing/include/internal/pycore_byteswap.h
@@ -0,0 +1,88 @@
+/* Bytes swap functions, reverse order of bytes:
+
+   - _Py_bswap16(uint16_t)
+   - _Py_bswap32(uint32_t)
+   - _Py_bswap64(uint64_t)
+*/
+
+#ifndef Py_INTERNAL_BSWAP_H
+#define Py_INTERNAL_BSWAP_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#if defined(__GNUC__) \
+      && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8))
+   /* __builtin_bswap16() is available since GCC 4.8,
+      __builtin_bswap32() is available since GCC 4.3,
+      __builtin_bswap64() is available since GCC 4.3. */
+#  define _PY_HAVE_BUILTIN_BSWAP
+#endif
+
+#ifdef _MSC_VER
+   /* Get _byteswap_ushort(), _byteswap_ulong(), _byteswap_uint64() */
+#  include 
+#endif
+
+static inline uint16_t
+_Py_bswap16(uint16_t word)
+{
+#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap16)
+    return __builtin_bswap16(word);
+#elif defined(_MSC_VER)
+    Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned short));
+    return _byteswap_ushort(word);
+#else
+    // Portable implementation which doesn't rely on circular bit shift
+    return ( ((word & UINT16_C(0x00FF)) << 8)
+           | ((word & UINT16_C(0xFF00)) >> 8));
+#endif
+}
+
+static inline uint32_t
+_Py_bswap32(uint32_t word)
+{
+#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap32)
+    return __builtin_bswap32(word);
+#elif defined(_MSC_VER)
+    Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned long));
+    return _byteswap_ulong(word);
+#else
+    // Portable implementation which doesn't rely on circular bit shift
+    return ( ((word & UINT32_C(0x000000FF)) << 24)
+           | ((word & UINT32_C(0x0000FF00)) <<  8)
+           | ((word & UINT32_C(0x00FF0000)) >>  8)
+           | ((word & UINT32_C(0xFF000000)) >> 24));
+#endif
+}
+
+static inline uint64_t
+_Py_bswap64(uint64_t word)
+{
+#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap64)
+    return __builtin_bswap64(word);
+#elif defined(_MSC_VER)
+    return _byteswap_uint64(word);
+#else
+    // Portable implementation which doesn't rely on circular bit shift
+    return ( ((word & UINT64_C(0x00000000000000FF)) << 56)
+           | ((word & UINT64_C(0x000000000000FF00)) << 40)
+           | ((word & UINT64_C(0x0000000000FF0000)) << 24)
+           | ((word & UINT64_C(0x00000000FF000000)) <<  8)
+           | ((word & UINT64_C(0x000000FF00000000)) >>  8)
+           | ((word & UINT64_C(0x0000FF0000000000)) >> 24)
+           | ((word & UINT64_C(0x00FF000000000000)) >> 40)
+           | ((word & UINT64_C(0xFF00000000000000)) >> 56));
+#endif
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_BSWAP_H */
+
diff --git a/marketing/include/internal/pycore_call.h b/marketing/include/internal/pycore_call.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7d856a54bd4a9d60accf14f3ba52068804a15fd
--- /dev/null
+++ b/marketing/include/internal/pycore_call.h
@@ -0,0 +1,39 @@
+#ifndef Py_INTERNAL_CALL_H
+#define Py_INTERNAL_CALL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend(
+    PyThreadState *tstate,
+    PyObject *callable,
+    PyObject *obj,
+    PyObject *args,
+    PyObject *kwargs);
+
+PyAPI_FUNC(PyObject *) _PyObject_FastCallDictTstate(
+    PyThreadState *tstate,
+    PyObject *callable,
+    PyObject *const *args,
+    size_t nargsf,
+    PyObject *kwargs);
+
+PyAPI_FUNC(PyObject *) _PyObject_Call(
+    PyThreadState *tstate,
+    PyObject *callable,
+    PyObject *args,
+    PyObject *kwargs);
+
+static inline PyObject *
+_PyObject_CallNoArgTstate(PyThreadState *tstate, PyObject *func) {
+    return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL);
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_CALL_H */
diff --git a/marketing/include/internal/pycore_ceval.h b/marketing/include/internal/pycore_ceval.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7ace9bd01c2a907d6865d6246e614e7044505f2
--- /dev/null
+++ b/marketing/include/internal/pycore_ceval.h
@@ -0,0 +1,108 @@
+#ifndef Py_INTERNAL_CEVAL_H
+#define Py_INTERNAL_CEVAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/* Forward declarations */
+struct pyruntimestate;
+struct _ceval_runtime_state;
+
+#include "pycore_interp.h"   /* PyInterpreterState.eval_frame */
+
+extern void _Py_FinishPendingCalls(PyThreadState *tstate);
+extern void _PyEval_InitRuntimeState(struct _ceval_runtime_state *);
+extern int _PyEval_InitState(struct _ceval_state *ceval);
+extern void _PyEval_FiniState(struct _ceval_state *ceval);
+PyAPI_FUNC(void) _PyEval_SignalReceived(PyInterpreterState *interp);
+PyAPI_FUNC(int) _PyEval_AddPendingCall(
+    PyInterpreterState *interp,
+    int (*func)(void *),
+    void *arg);
+PyAPI_FUNC(void) _PyEval_SignalAsyncExc(PyThreadState *tstate);
+#ifdef HAVE_FORK
+extern void _PyEval_ReInitThreads(struct pyruntimestate *runtime);
+#endif
+PyAPI_FUNC(void) _PyEval_SetCoroutineOriginTrackingDepth(
+    PyThreadState *tstate,
+    int new_depth);
+
+/* Private function */
+void _PyEval_Fini(void);
+
+static inline PyObject*
+_PyEval_EvalFrame(PyThreadState *tstate, PyFrameObject *f, int throwflag)
+{
+    return tstate->interp->eval_frame(tstate, f, throwflag);
+}
+
+extern PyObject *_PyEval_EvalCode(
+    PyThreadState *tstate,
+    PyObject *_co, PyObject *globals, PyObject *locals,
+    PyObject *const *args, Py_ssize_t argcount,
+    PyObject *const *kwnames, PyObject *const *kwargs,
+    Py_ssize_t kwcount, int kwstep,
+    PyObject *const *defs, Py_ssize_t defcount,
+    PyObject *kwdefs, PyObject *closure,
+    PyObject *name, PyObject *qualname);
+
+extern int _PyEval_ThreadsInitialized(struct pyruntimestate *runtime);
+extern PyStatus _PyEval_InitGIL(PyThreadState *tstate);
+extern void _PyEval_FiniGIL(PyThreadState *tstate);
+
+extern void _PyEval_ReleaseLock(PyThreadState *tstate);
+
+
+/* --- _Py_EnterRecursiveCall() ----------------------------------------- */
+
+PyAPI_DATA(int) _Py_CheckRecursionLimit;
+
+#ifdef USE_STACKCHECK
+/* With USE_STACKCHECK macro defined, trigger stack checks in
+   _Py_CheckRecursiveCall() on every 64th call to Py_EnterRecursiveCall. */
+static inline int _Py_MakeRecCheck(PyThreadState *tstate)  {
+    return (++tstate->recursion_depth > tstate->interp->ceval.recursion_limit
+            || ++tstate->stackcheck_counter > 64);
+}
+#else
+static inline int _Py_MakeRecCheck(PyThreadState *tstate) {
+    return (++tstate->recursion_depth > tstate->interp->ceval.recursion_limit);
+}
+#endif
+
+PyAPI_FUNC(int) _Py_CheckRecursiveCall(
+    PyThreadState *tstate,
+    const char *where);
+
+static inline int _Py_EnterRecursiveCall(PyThreadState *tstate,
+                                         const char *where) {
+    return (_Py_MakeRecCheck(tstate) && _Py_CheckRecursiveCall(tstate, where));
+}
+
+static inline int _Py_EnterRecursiveCall_inline(const char *where) {
+    PyThreadState *tstate = PyThreadState_GET();
+    return _Py_EnterRecursiveCall(tstate, where);
+}
+
+#define Py_EnterRecursiveCall(where) _Py_EnterRecursiveCall_inline(where)
+
+static inline void _Py_LeaveRecursiveCall(PyThreadState *tstate)  {
+    tstate->recursion_depth--;
+}
+
+static inline void _Py_LeaveRecursiveCall_inline(void)  {
+    PyThreadState *tstate = PyThreadState_GET();
+    _Py_LeaveRecursiveCall(tstate);
+}
+
+#define Py_LeaveRecursiveCall() _Py_LeaveRecursiveCall_inline()
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_CEVAL_H */
diff --git a/marketing/include/internal/pycore_code.h b/marketing/include/internal/pycore_code.h
new file mode 100644
index 0000000000000000000000000000000000000000..a1bd6a0bc0f346142ba865f765e1c3b5f43d7951
--- /dev/null
+++ b/marketing/include/internal/pycore_code.h
@@ -0,0 +1,27 @@
+#ifndef Py_INTERNAL_CODE_H
+#define Py_INTERNAL_CODE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject *ptr;  /* Cached pointer (borrowed reference) */
+    uint64_t globals_ver;  /* ma_version of global dict */
+    uint64_t builtins_ver; /* ma_version of builtin dict */
+} _PyOpcache_LoadGlobal;
+
+struct _PyOpcache {
+    union {
+        _PyOpcache_LoadGlobal lg;
+    } u;
+    char optimized;
+};
+
+/* Private API */
+int _PyCode_InitOpcache(PyCodeObject *co);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_CODE_H */
diff --git a/marketing/include/internal/pycore_condvar.h b/marketing/include/internal/pycore_condvar.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b89d709510a3382a94e919f4d8ee56f7f1c21a0
--- /dev/null
+++ b/marketing/include/internal/pycore_condvar.h
@@ -0,0 +1,95 @@
+#ifndef Py_INTERNAL_CONDVAR_H
+#define Py_INTERNAL_CONDVAR_H
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#ifndef _POSIX_THREADS
+/* This means pthreads are not implemented in libc headers, hence the macro
+   not present in unistd.h. But they still can be implemented as an external
+   library (e.g. gnu pth in pthread emulation) */
+# ifdef HAVE_PTHREAD_H
+#  include  /* _POSIX_THREADS */
+# endif
+#endif
+
+#ifdef _POSIX_THREADS
+/*
+ * POSIX support
+ */
+#define Py_HAVE_CONDVAR
+
+#include 
+
+#define PyMUTEX_T pthread_mutex_t
+#define PyCOND_T pthread_cond_t
+
+#elif defined(NT_THREADS)
+/*
+ * Windows (XP, 2003 server and later, as well as (hopefully) CE) support
+ *
+ * Emulated condition variables ones that work with XP and later, plus
+ * example native support on VISTA and onwards.
+ */
+#define Py_HAVE_CONDVAR
+
+/* include windows if it hasn't been done before */
+#define WIN32_LEAN_AND_MEAN
+#include 
+
+/* options */
+/* non-emulated condition variables are provided for those that want
+ * to target Windows Vista.  Modify this macro to enable them.
+ */
+#ifndef _PY_EMULATED_WIN_CV
+#define _PY_EMULATED_WIN_CV 1  /* use emulated condition variables */
+#endif
+
+/* fall back to emulation if not targeting Vista */
+#if !defined NTDDI_VISTA || NTDDI_VERSION < NTDDI_VISTA
+#undef _PY_EMULATED_WIN_CV
+#define _PY_EMULATED_WIN_CV 1
+#endif
+
+#if _PY_EMULATED_WIN_CV
+
+typedef CRITICAL_SECTION PyMUTEX_T;
+
+/* The ConditionVariable object.  From XP onwards it is easily emulated
+   with a Semaphore.
+   Semaphores are available on Windows XP (2003 server) and later.
+   We use a Semaphore rather than an auto-reset event, because although
+   an auto-resent event might appear to solve the lost-wakeup bug (race
+   condition between releasing the outer lock and waiting) because it
+   maintains state even though a wait hasn't happened, there is still
+   a lost wakeup problem if more than one thread are interrupted in the
+   critical place.  A semaphore solves that, because its state is
+   counted, not Boolean.
+   Because it is ok to signal a condition variable with no one
+   waiting, we need to keep track of the number of
+   waiting threads.  Otherwise, the semaphore's state could rise
+   without bound.  This also helps reduce the number of "spurious wakeups"
+   that would otherwise happen.
+ */
+
+typedef struct _PyCOND_T
+{
+    HANDLE sem;
+    int waiting; /* to allow PyCOND_SIGNAL to be a no-op */
+} PyCOND_T;
+
+#else /* !_PY_EMULATED_WIN_CV */
+
+/* Use native Win7 primitives if build target is Win7 or higher */
+
+/* SRWLOCK is faster and better than CriticalSection */
+typedef SRWLOCK PyMUTEX_T;
+
+typedef CONDITION_VARIABLE  PyCOND_T;
+
+#endif /* _PY_EMULATED_WIN_CV */
+
+#endif /* _POSIX_THREADS, NT_THREADS */
+
+#endif /* Py_INTERNAL_CONDVAR_H */
diff --git a/marketing/include/internal/pycore_context.h b/marketing/include/internal/pycore_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..f665ad5c115b07ac839917db3271ade9b4663475
--- /dev/null
+++ b/marketing/include/internal/pycore_context.h
@@ -0,0 +1,42 @@
+#ifndef Py_INTERNAL_CONTEXT_H
+#define Py_INTERNAL_CONTEXT_H
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "pycore_hamt.h"   /* PyHamtObject */
+
+struct _pycontextobject {
+    PyObject_HEAD
+    PyContext *ctx_prev;
+    PyHamtObject *ctx_vars;
+    PyObject *ctx_weakreflist;
+    int ctx_entered;
+};
+
+
+struct _pycontextvarobject {
+    PyObject_HEAD
+    PyObject *var_name;
+    PyObject *var_default;
+    PyObject *var_cached;
+    uint64_t var_cached_tsid;
+    uint64_t var_cached_tsver;
+    Py_hash_t var_hash;
+};
+
+
+struct _pycontexttokenobject {
+    PyObject_HEAD
+    PyContext *tok_ctx;
+    PyContextVar *tok_var;
+    PyObject *tok_oldval;
+    int tok_used;
+};
+
+
+int _PyContext_Init(void);
+void _PyContext_Fini(void);
+
+#endif /* !Py_INTERNAL_CONTEXT_H */
diff --git a/marketing/include/internal/pycore_dtoa.h b/marketing/include/internal/pycore_dtoa.h
new file mode 100644
index 0000000000000000000000000000000000000000..3faf8cf6b2eefc7d7fe688e3df95c94a6ca52e85
--- /dev/null
+++ b/marketing/include/internal/pycore_dtoa.h
@@ -0,0 +1,23 @@
+#ifndef PY_NO_SHORT_FLOAT_REPR
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/* These functions are used by modules compiled as C extension like math:
+   they must be exported. */
+
+PyAPI_FUNC(double) _Py_dg_strtod(const char *str, char **ptr);
+PyAPI_FUNC(char *) _Py_dg_dtoa(double d, int mode, int ndigits,
+                        int *decpt, int *sign, char **rve);
+PyAPI_FUNC(void) _Py_dg_freedtoa(char *s);
+PyAPI_FUNC(double) _Py_dg_stdnan(int sign);
+PyAPI_FUNC(double) _Py_dg_infinity(int sign);
+
+#ifdef __cplusplus
+}
+#endif
+#endif   /* !PY_NO_SHORT_FLOAT_REPR */
diff --git a/marketing/include/internal/pycore_fileutils.h b/marketing/include/internal/pycore_fileutils.h
new file mode 100644
index 0000000000000000000000000000000000000000..8cf137bb4bdf9dc89ed24cb4cdde391f4588f980
--- /dev/null
+++ b/marketing/include/internal/pycore_fileutils.h
@@ -0,0 +1,66 @@
+#ifndef Py_INTERNAL_FILEUTILS_H
+#define Py_INTERNAL_FILEUTILS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "Py_BUILD_CORE must be defined to include this header"
+#endif
+
+#include    /* struct lconv */
+
+PyAPI_DATA(int) _Py_HasFileSystemDefaultEncodeErrors;
+
+PyAPI_FUNC(int) _Py_DecodeUTF8Ex(
+    const char *arg,
+    Py_ssize_t arglen,
+    wchar_t **wstr,
+    size_t *wlen,
+    const char **reason,
+    _Py_error_handler errors);
+
+PyAPI_FUNC(int) _Py_EncodeUTF8Ex(
+    const wchar_t *text,
+    char **str,
+    size_t *error_pos,
+    const char **reason,
+    int raw_malloc,
+    _Py_error_handler errors);
+
+PyAPI_FUNC(wchar_t*) _Py_DecodeUTF8_surrogateescape(
+    const char *arg,
+    Py_ssize_t arglen,
+    size_t *wlen);
+
+PyAPI_FUNC(int) _Py_GetForceASCII(void);
+
+/* Reset "force ASCII" mode (if it was initialized).
+
+   This function should be called when Python changes the LC_CTYPE locale,
+   so the "force ASCII" mode can be detected again on the new locale
+   encoding. */
+PyAPI_FUNC(void) _Py_ResetForceASCII(void);
+
+
+PyAPI_FUNC(int) _Py_GetLocaleconvNumeric(
+    struct lconv *lc,
+    PyObject **decimal_point,
+    PyObject **thousands_sep);
+
+#ifdef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION
+extern int _Py_LocaleUsesNonUnicodeWchar(void);
+
+extern wchar_t* _Py_DecodeNonUnicodeWchar(
+    const wchar_t* native,
+    Py_ssize_t size);
+
+extern int _Py_EncodeNonUnicodeWchar_InPlace(
+    wchar_t* unicode,
+    Py_ssize_t size);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_FILEUTILS_H */
diff --git a/marketing/include/internal/pycore_gc.h b/marketing/include/internal/pycore_gc.h
new file mode 100644
index 0000000000000000000000000000000000000000..0511eea779a7e7dfa78d7676de3a3d1671a0fef7
--- /dev/null
+++ b/marketing/include/internal/pycore_gc.h
@@ -0,0 +1,179 @@
+#ifndef Py_INTERNAL_GC_H
+#define Py_INTERNAL_GC_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/* GC information is stored BEFORE the object structure. */
+typedef struct {
+    // Pointer to next object in the list.
+    // 0 means the object is not tracked
+    uintptr_t _gc_next;
+
+    // Pointer to previous object in the list.
+    // Lowest two bits are used for flags documented later.
+    uintptr_t _gc_prev;
+} PyGC_Head;
+
+#define _Py_AS_GC(o) ((PyGC_Head *)(o)-1)
+
+/* True if the object is currently tracked by the GC. */
+#define _PyObject_GC_IS_TRACKED(o) (_Py_AS_GC(o)->_gc_next != 0)
+
+/* True if the object may be tracked by the GC in the future, or already is.
+   This can be useful to implement some optimizations. */
+#define _PyObject_GC_MAY_BE_TRACKED(obj) \
+    (PyObject_IS_GC(obj) && \
+        (!PyTuple_CheckExact(obj) || _PyObject_GC_IS_TRACKED(obj)))
+
+
+/* Bit flags for _gc_prev */
+/* Bit 0 is set when tp_finalize is called */
+#define _PyGC_PREV_MASK_FINALIZED  (1)
+/* Bit 1 is set when the object is in generation which is GCed currently. */
+#define _PyGC_PREV_MASK_COLLECTING (2)
+/* The (N-2) most significant bits contain the real address. */
+#define _PyGC_PREV_SHIFT           (2)
+#define _PyGC_PREV_MASK            (((uintptr_t) -1) << _PyGC_PREV_SHIFT)
+
+// Lowest bit of _gc_next is used for flags only in GC.
+// But it is always 0 for normal code.
+#define _PyGCHead_NEXT(g)        ((PyGC_Head*)(g)->_gc_next)
+#define _PyGCHead_SET_NEXT(g, p) ((g)->_gc_next = (uintptr_t)(p))
+
+// Lowest two bits of _gc_prev is used for _PyGC_PREV_MASK_* flags.
+#define _PyGCHead_PREV(g) ((PyGC_Head*)((g)->_gc_prev & _PyGC_PREV_MASK))
+#define _PyGCHead_SET_PREV(g, p) do { \
+    assert(((uintptr_t)p & ~_PyGC_PREV_MASK) == 0); \
+    (g)->_gc_prev = ((g)->_gc_prev & ~_PyGC_PREV_MASK) \
+        | ((uintptr_t)(p)); \
+    } while (0)
+
+#define _PyGCHead_FINALIZED(g) \
+    (((g)->_gc_prev & _PyGC_PREV_MASK_FINALIZED) != 0)
+#define _PyGCHead_SET_FINALIZED(g) \
+    ((g)->_gc_prev |= _PyGC_PREV_MASK_FINALIZED)
+
+#define _PyGC_FINALIZED(o) \
+    _PyGCHead_FINALIZED(_Py_AS_GC(o))
+#define _PyGC_SET_FINALIZED(o) \
+    _PyGCHead_SET_FINALIZED(_Py_AS_GC(o))
+
+
+/* GC runtime state */
+
+/* If we change this, we need to change the default value in the
+   signature of gc.collect. */
+#define NUM_GENERATIONS 3
+/*
+   NOTE: about untracking of mutable objects.
+
+   Certain types of container cannot participate in a reference cycle, and
+   so do not need to be tracked by the garbage collector. Untracking these
+   objects reduces the cost of garbage collections. However, determining
+   which objects may be untracked is not free, and the costs must be
+   weighed against the benefits for garbage collection.
+
+   There are two possible strategies for when to untrack a container:
+
+   i) When the container is created.
+   ii) When the container is examined by the garbage collector.
+
+   Tuples containing only immutable objects (integers, strings etc, and
+   recursively, tuples of immutable objects) do not need to be tracked.
+   The interpreter creates a large number of tuples, many of which will
+   not survive until garbage collection. It is therefore not worthwhile
+   to untrack eligible tuples at creation time.
+
+   Instead, all tuples except the empty tuple are tracked when created.
+   During garbage collection it is determined whether any surviving tuples
+   can be untracked. A tuple can be untracked if all of its contents are
+   already not tracked. Tuples are examined for untracking in all garbage
+   collection cycles. It may take more than one cycle to untrack a tuple.
+
+   Dictionaries containing only immutable objects also do not need to be
+   tracked. Dictionaries are untracked when created. If a tracked item is
+   inserted into a dictionary (either as a key or value), the dictionary
+   becomes tracked. During a full garbage collection (all generations),
+   the collector will untrack any dictionaries whose contents are not
+   tracked.
+
+   The module provides the python function is_tracked(obj), which returns
+   the CURRENT tracking status of the object. Subsequent garbage
+   collections may change the tracking status of the object.
+
+   Untracking of certain containers was introduced in issue #4688, and
+   the algorithm was refined in response to issue #14775.
+*/
+
+struct gc_generation {
+    PyGC_Head head;
+    int threshold; /* collection threshold */
+    int count; /* count of allocations or collections of younger
+                  generations */
+};
+
+/* Running stats per generation */
+struct gc_generation_stats {
+    /* total number of collections */
+    Py_ssize_t collections;
+    /* total number of collected objects */
+    Py_ssize_t collected;
+    /* total number of uncollectable objects (put into gc.garbage) */
+    Py_ssize_t uncollectable;
+};
+
+struct _gc_runtime_state {
+    /* List of objects that still need to be cleaned up, singly linked
+     * via their gc headers' gc_prev pointers.  */
+    PyObject *trash_delete_later;
+    /* Current call-stack depth of tp_dealloc calls. */
+    int trash_delete_nesting;
+
+    int enabled;
+    int debug;
+    /* linked lists of container objects */
+    struct gc_generation generations[NUM_GENERATIONS];
+    PyGC_Head *generation0;
+    /* a permanent generation which won't be collected */
+    struct gc_generation permanent_generation;
+    struct gc_generation_stats generation_stats[NUM_GENERATIONS];
+    /* true if we are currently running the collector */
+    int collecting;
+    /* list of uncollectable objects */
+    PyObject *garbage;
+    /* a list of callbacks to be invoked when collection is performed */
+    PyObject *callbacks;
+    /* This is the number of objects that survived the last full
+       collection. It approximates the number of long lived objects
+       tracked by the GC.
+
+       (by "full collection", we mean a collection of the oldest
+       generation). */
+    Py_ssize_t long_lived_total;
+    /* This is the number of objects that survived all "non-full"
+       collections, and are awaiting to undergo a full collection for
+       the first time. */
+    Py_ssize_t long_lived_pending;
+};
+
+PyAPI_FUNC(void) _PyGC_InitState(struct _gc_runtime_state *);
+
+
+// Functions to clear types free lists
+extern void _PyFrame_ClearFreeList(void);
+extern void _PyTuple_ClearFreeList(void);
+extern void _PyFloat_ClearFreeList(void);
+extern void _PyList_ClearFreeList(void);
+extern void _PyDict_ClearFreeList(void);
+extern void _PyAsyncGen_ClearFreeLists(void);
+extern void _PyContext_ClearFreeList(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_GC_H */
diff --git a/marketing/include/internal/pycore_getopt.h b/marketing/include/internal/pycore_getopt.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f0dd13ae577f78491f19b7e8fa3ac8c5042bb11
--- /dev/null
+++ b/marketing/include/internal/pycore_getopt.h
@@ -0,0 +1,22 @@
+#ifndef Py_INTERNAL_PYGETOPT_H
+#define Py_INTERNAL_PYGETOPT_H
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+extern int _PyOS_opterr;
+extern Py_ssize_t _PyOS_optind;
+extern const wchar_t *_PyOS_optarg;
+
+extern void _PyOS_ResetGetOpt(void);
+
+typedef struct {
+    const wchar_t *name;
+    int has_arg;
+    int val;
+} _PyOS_LongOption;
+
+extern int _PyOS_GetOpt(Py_ssize_t argc, wchar_t * const *argv, int *longindex);
+
+#endif /* !Py_INTERNAL_PYGETOPT_H */
diff --git a/marketing/include/internal/pycore_gil.h b/marketing/include/internal/pycore_gil.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ebad37b686cd4c9cdfd4236b2bd9387497f489e
--- /dev/null
+++ b/marketing/include/internal/pycore_gil.h
@@ -0,0 +1,50 @@
+#ifndef Py_INTERNAL_GIL_H
+#define Py_INTERNAL_GIL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "pycore_atomic.h"    /* _Py_atomic_address */
+#include "pycore_condvar.h"   /* PyCOND_T */
+
+#ifndef Py_HAVE_CONDVAR
+#  error You need either a POSIX-compatible or a Windows system!
+#endif
+
+/* Enable if you want to force the switching of threads at least
+   every `interval`. */
+#undef FORCE_SWITCHING
+#define FORCE_SWITCHING
+
+struct _gil_runtime_state {
+    /* microseconds (the Python API uses seconds, though) */
+    unsigned long interval;
+    /* Last PyThreadState holding / having held the GIL. This helps us
+       know whether anyone else was scheduled after we dropped the GIL. */
+    _Py_atomic_address last_holder;
+    /* Whether the GIL is already taken (-1 if uninitialized). This is
+       atomic because it can be read without any lock taken in ceval.c. */
+    _Py_atomic_int locked;
+    /* Number of GIL switches since the beginning. */
+    unsigned long switch_number;
+    /* This condition variable allows one or several threads to wait
+       until the GIL is released. In addition, the mutex also protects
+       the above variables. */
+    PyCOND_T cond;
+    PyMUTEX_T mutex;
+#ifdef FORCE_SWITCHING
+    /* This condition variable helps the GIL-releasing thread wait for
+       a GIL-awaiting thread to be scheduled and take the GIL. */
+    PyCOND_T switch_cond;
+    PyMUTEX_T switch_mutex;
+#endif
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_GIL_H */
diff --git a/marketing/include/internal/pycore_hamt.h b/marketing/include/internal/pycore_hamt.h
new file mode 100644
index 0000000000000000000000000000000000000000..357d96616272a7723af65d64bb26ab0aae70bc2a
--- /dev/null
+++ b/marketing/include/internal/pycore_hamt.h
@@ -0,0 +1,128 @@
+#ifndef Py_INTERNAL_HAMT_H
+#define Py_INTERNAL_HAMT_H
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+
+/*
+HAMT tree is shaped by hashes of keys. Every group of 5 bits of a hash denotes
+the exact position of the key in one level of the tree. Since we're using
+32 bit hashes, we can have at most 7 such levels. Although if there are
+two distinct keys with equal hashes, they will have to occupy the same
+cell in the 7th level of the tree -- so we'd put them in a "collision" node.
+Which brings the total possible tree depth to 8. Read more about the actual
+layout of the HAMT tree in `hamt.c`.
+
+This constant is used to define a datastucture for storing iteration state.
+*/
+#define _Py_HAMT_MAX_TREE_DEPTH 8
+
+
+#define PyHamt_Check(o) Py_IS_TYPE(o, &_PyHamt_Type)
+
+
+/* Abstract tree node. */
+typedef struct {
+    PyObject_HEAD
+} PyHamtNode;
+
+
+/* An HAMT immutable mapping collection. */
+typedef struct {
+    PyObject_HEAD
+    PyHamtNode *h_root;
+    PyObject *h_weakreflist;
+    Py_ssize_t h_count;
+} PyHamtObject;
+
+
+/* A struct to hold the state of depth-first traverse of the tree.
+
+   HAMT is an immutable collection.  Iterators will hold a strong reference
+   to it, and every node in the HAMT has strong references to its children.
+
+   So for iterators, we can implement zero allocations and zero reference
+   inc/dec depth-first iteration.
+
+   - i_nodes: an array of seven pointers to tree nodes
+   - i_level: the current node in i_nodes
+   - i_pos: an array of positions within nodes in i_nodes.
+*/
+typedef struct {
+    PyHamtNode *i_nodes[_Py_HAMT_MAX_TREE_DEPTH];
+    Py_ssize_t i_pos[_Py_HAMT_MAX_TREE_DEPTH];
+    int8_t i_level;
+} PyHamtIteratorState;
+
+
+/* Base iterator object.
+
+   Contains the iteration state, a pointer to the HAMT tree,
+   and a pointer to the 'yield function'.  The latter is a simple
+   function that returns a key/value tuple for the 'Items' iterator,
+   just a key for the 'Keys' iterator, and a value for the 'Values'
+   iterator.
+*/
+typedef struct {
+    PyObject_HEAD
+    PyHamtObject *hi_obj;
+    PyHamtIteratorState hi_iter;
+    binaryfunc hi_yield;
+} PyHamtIterator;
+
+
+PyAPI_DATA(PyTypeObject) _PyHamt_Type;
+PyAPI_DATA(PyTypeObject) _PyHamt_ArrayNode_Type;
+PyAPI_DATA(PyTypeObject) _PyHamt_BitmapNode_Type;
+PyAPI_DATA(PyTypeObject) _PyHamt_CollisionNode_Type;
+PyAPI_DATA(PyTypeObject) _PyHamtKeys_Type;
+PyAPI_DATA(PyTypeObject) _PyHamtValues_Type;
+PyAPI_DATA(PyTypeObject) _PyHamtItems_Type;
+
+
+/* Create a new HAMT immutable mapping. */
+PyHamtObject * _PyHamt_New(void);
+
+/* Return a new collection based on "o", but with an additional
+   key/val pair. */
+PyHamtObject * _PyHamt_Assoc(PyHamtObject *o, PyObject *key, PyObject *val);
+
+/* Return a new collection based on "o", but without "key". */
+PyHamtObject * _PyHamt_Without(PyHamtObject *o, PyObject *key);
+
+/* Find "key" in the "o" collection.
+
+   Return:
+   - -1: An error occurred.
+   - 0: "key" wasn't found in "o".
+   - 1: "key" is in "o"; "*val" is set to its value (a borrowed ref).
+*/
+int _PyHamt_Find(PyHamtObject *o, PyObject *key, PyObject **val);
+
+/* Check if "v" is equal to "w".
+
+   Return:
+   - 0: v != w
+   - 1: v == w
+   - -1: An error occurred.
+*/
+int _PyHamt_Eq(PyHamtObject *v, PyHamtObject *w);
+
+/* Return the size of "o"; equivalent of "len(o)". */
+Py_ssize_t _PyHamt_Len(PyHamtObject *o);
+
+/* Return a Keys iterator over "o". */
+PyObject * _PyHamt_NewIterKeys(PyHamtObject *o);
+
+/* Return a Values iterator over "o". */
+PyObject * _PyHamt_NewIterValues(PyHamtObject *o);
+
+/* Return a Items iterator over "o". */
+PyObject * _PyHamt_NewIterItems(PyHamtObject *o);
+
+int _PyHamt_Init(void);
+void _PyHamt_Fini(void);
+
+#endif /* !Py_INTERNAL_HAMT_H */
diff --git a/marketing/include/internal/pycore_hashtable.h b/marketing/include/internal/pycore_hashtable.h
new file mode 100644
index 0000000000000000000000000000000000000000..18757abc28c195883b6e3e1cd39e501a85e45381
--- /dev/null
+++ b/marketing/include/internal/pycore_hashtable.h
@@ -0,0 +1,148 @@
+#ifndef Py_INTERNAL_HASHTABLE_H
+#define Py_INTERNAL_HASHTABLE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/* Single linked list */
+
+typedef struct _Py_slist_item_s {
+    struct _Py_slist_item_s *next;
+} _Py_slist_item_t;
+
+typedef struct {
+    _Py_slist_item_t *head;
+} _Py_slist_t;
+
+#define _Py_SLIST_ITEM_NEXT(ITEM) (((_Py_slist_item_t *)ITEM)->next)
+
+#define _Py_SLIST_HEAD(SLIST) (((_Py_slist_t *)SLIST)->head)
+
+
+/* _Py_hashtable: table entry */
+
+typedef struct {
+    /* used by _Py_hashtable_t.buckets to link entries */
+    _Py_slist_item_t _Py_slist_item;
+
+    Py_uhash_t key_hash;
+    void *key;
+    void *value;
+} _Py_hashtable_entry_t;
+
+
+/* _Py_hashtable: prototypes */
+
+/* Forward declaration */
+struct _Py_hashtable_t;
+typedef struct _Py_hashtable_t _Py_hashtable_t;
+
+typedef Py_uhash_t (*_Py_hashtable_hash_func) (const void *key);
+typedef int (*_Py_hashtable_compare_func) (const void *key1, const void *key2);
+typedef void (*_Py_hashtable_destroy_func) (void *key);
+typedef _Py_hashtable_entry_t* (*_Py_hashtable_get_entry_func)(_Py_hashtable_t *ht,
+                                                               const void *key);
+
+typedef struct {
+    // Allocate a memory block
+    void* (*malloc) (size_t size);
+
+    // Release a memory block
+    void (*free) (void *ptr);
+} _Py_hashtable_allocator_t;
+
+
+/* _Py_hashtable: table */
+struct _Py_hashtable_t {
+    size_t nentries; // Total number of entries in the table
+    size_t nbuckets;
+    _Py_slist_t *buckets;
+
+    _Py_hashtable_get_entry_func get_entry_func;
+    _Py_hashtable_hash_func hash_func;
+    _Py_hashtable_compare_func compare_func;
+    _Py_hashtable_destroy_func key_destroy_func;
+    _Py_hashtable_destroy_func value_destroy_func;
+    _Py_hashtable_allocator_t alloc;
+};
+
+/* Hash a pointer (void*) */
+PyAPI_FUNC(Py_uhash_t) _Py_hashtable_hash_ptr(const void *key);
+
+/* Comparison using memcmp() */
+PyAPI_FUNC(int) _Py_hashtable_compare_direct(
+    const void *key1,
+    const void *key2);
+
+PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new(
+    _Py_hashtable_hash_func hash_func,
+    _Py_hashtable_compare_func compare_func);
+
+PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new_full(
+    _Py_hashtable_hash_func hash_func,
+    _Py_hashtable_compare_func compare_func,
+    _Py_hashtable_destroy_func key_destroy_func,
+    _Py_hashtable_destroy_func value_destroy_func,
+    _Py_hashtable_allocator_t *allocator);
+
+PyAPI_FUNC(void) _Py_hashtable_destroy(_Py_hashtable_t *ht);
+
+PyAPI_FUNC(void) _Py_hashtable_clear(_Py_hashtable_t *ht);
+
+typedef int (*_Py_hashtable_foreach_func) (_Py_hashtable_t *ht,
+                                           const void *key, const void *value,
+                                           void *user_data);
+
+/* Call func() on each entry of the hashtable.
+   Iteration stops if func() result is non-zero, in this case it's the result
+   of the call. Otherwise, the function returns 0. */
+PyAPI_FUNC(int) _Py_hashtable_foreach(
+    _Py_hashtable_t *ht,
+    _Py_hashtable_foreach_func func,
+    void *user_data);
+
+PyAPI_FUNC(size_t) _Py_hashtable_size(const _Py_hashtable_t *ht);
+
+/* Add a new entry to the hash. The key must not be present in the hash table.
+   Return 0 on success, -1 on memory error. */
+PyAPI_FUNC(int) _Py_hashtable_set(
+    _Py_hashtable_t *ht,
+    const void *key,
+    void *value);
+
+
+/* Get an entry.
+   Return NULL if the key does not exist. */
+static inline _Py_hashtable_entry_t *
+_Py_hashtable_get_entry(_Py_hashtable_t *ht, const void *key)
+{
+    return ht->get_entry_func(ht, key);
+}
+
+
+/* Get value from an entry.
+   Return NULL if the entry is not found.
+
+   Use _Py_hashtable_get_entry() to distinguish entry value equal to NULL
+   and entry not found. */
+PyAPI_FUNC(void*) _Py_hashtable_get(_Py_hashtable_t *ht, const void *key);
+
+
+/* Remove a key and its associated value without calling key and value destroy
+   functions.
+
+   Return the removed value if the key was found.
+   Return NULL if the key was not found. */
+PyAPI_FUNC(void*) _Py_hashtable_steal(
+    _Py_hashtable_t *ht,
+    const void *key);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif   /* !Py_INTERNAL_HASHTABLE_H */
diff --git a/marketing/include/internal/pycore_import.h b/marketing/include/internal/pycore_import.h
new file mode 100644
index 0000000000000000000000000000000000000000..b011ea4425112b13fc214de954f348df3f09f92b
--- /dev/null
+++ b/marketing/include/internal/pycore_import.h
@@ -0,0 +1,22 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_INTERNAL_IMPORT_H
+#define Py_INTERNAL_IMPORT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(PyObject *) _PyImport_FindBuiltin(
+    PyThreadState *tstate,
+    const char *name             /* UTF-8 encoded string */
+    );
+
+#ifdef HAVE_FORK
+extern void _PyImport_ReInitLock(void);
+#endif
+extern void _PyImport_Cleanup(PyThreadState *tstate);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_IMPORT_H */
+#endif /* !Py_LIMITED_API */
diff --git a/marketing/include/internal/pycore_initconfig.h b/marketing/include/internal/pycore_initconfig.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad1b7e55e0140f200af1afddf732b32573110716
--- /dev/null
+++ b/marketing/include/internal/pycore_initconfig.h
@@ -0,0 +1,169 @@
+#ifndef Py_INTERNAL_CORECONFIG_H
+#define Py_INTERNAL_CORECONFIG_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/* Forward declaration */
+struct pyruntimestate;
+
+/* --- PyStatus ----------------------------------------------- */
+
+/* Almost all errors causing Python initialization to fail */
+#ifdef _MSC_VER
+   /* Visual Studio 2015 doesn't implement C99 __func__ in C */
+#  define _PyStatus_GET_FUNC() __FUNCTION__
+#else
+#  define _PyStatus_GET_FUNC() __func__
+#endif
+
+#define _PyStatus_OK() \
+    (PyStatus){._type = _PyStatus_TYPE_OK,}
+    /* other fields are set to 0 */
+#define _PyStatus_ERR(ERR_MSG) \
+    (PyStatus){ \
+        ._type = _PyStatus_TYPE_ERROR, \
+        .func = _PyStatus_GET_FUNC(), \
+        .err_msg = (ERR_MSG)}
+        /* other fields are set to 0 */
+#define _PyStatus_NO_MEMORY() _PyStatus_ERR("memory allocation failed")
+#define _PyStatus_EXIT(EXITCODE) \
+    (PyStatus){ \
+        ._type = _PyStatus_TYPE_EXIT, \
+        .exitcode = (EXITCODE)}
+#define _PyStatus_IS_ERROR(err) \
+    (err._type == _PyStatus_TYPE_ERROR)
+#define _PyStatus_IS_EXIT(err) \
+    (err._type == _PyStatus_TYPE_EXIT)
+#define _PyStatus_EXCEPTION(err) \
+    (err._type != _PyStatus_TYPE_OK)
+#define _PyStatus_UPDATE_FUNC(err) \
+    do { err.func = _PyStatus_GET_FUNC(); } while (0)
+
+/* --- PyWideStringList ------------------------------------------------ */
+
+#define _PyWideStringList_INIT (PyWideStringList){.length = 0, .items = NULL}
+
+#ifndef NDEBUG
+PyAPI_FUNC(int) _PyWideStringList_CheckConsistency(const PyWideStringList *list);
+#endif
+PyAPI_FUNC(void) _PyWideStringList_Clear(PyWideStringList *list);
+PyAPI_FUNC(int) _PyWideStringList_Copy(PyWideStringList *list,
+    const PyWideStringList *list2);
+PyAPI_FUNC(PyStatus) _PyWideStringList_Extend(PyWideStringList *list,
+    const PyWideStringList *list2);
+PyAPI_FUNC(PyObject*) _PyWideStringList_AsList(const PyWideStringList *list);
+
+
+/* --- _PyArgv ---------------------------------------------------- */
+
+typedef struct _PyArgv {
+    Py_ssize_t argc;
+    int use_bytes_argv;
+    char * const *bytes_argv;
+    wchar_t * const *wchar_argv;
+} _PyArgv;
+
+PyAPI_FUNC(PyStatus) _PyArgv_AsWstrList(const _PyArgv *args,
+    PyWideStringList *list);
+
+
+/* --- Helper functions ------------------------------------------- */
+
+PyAPI_FUNC(int) _Py_str_to_int(
+    const char *str,
+    int *result);
+PyAPI_FUNC(const wchar_t*) _Py_get_xoption(
+    const PyWideStringList *xoptions,
+    const wchar_t *name);
+PyAPI_FUNC(const char*) _Py_GetEnv(
+    int use_environment,
+    const char *name);
+PyAPI_FUNC(void) _Py_get_env_flag(
+    int use_environment,
+    int *flag,
+    const char *name);
+
+/* Py_GetArgcArgv() helper */
+PyAPI_FUNC(void) _Py_ClearArgcArgv(void);
+
+
+/* --- _PyPreCmdline ------------------------------------------------- */
+
+typedef struct {
+    PyWideStringList argv;
+    PyWideStringList xoptions;     /* "-X value" option */
+    int isolated;             /* -I option */
+    int use_environment;      /* -E option */
+    int dev_mode;             /* -X dev and PYTHONDEVMODE */
+} _PyPreCmdline;
+
+#define _PyPreCmdline_INIT \
+    (_PyPreCmdline){ \
+        .use_environment = -1, \
+        .isolated = -1, \
+        .dev_mode = -1}
+/* Note: _PyPreCmdline_INIT sets other fields to 0/NULL */
+
+extern void _PyPreCmdline_Clear(_PyPreCmdline *cmdline);
+extern PyStatus _PyPreCmdline_SetArgv(_PyPreCmdline *cmdline,
+    const _PyArgv *args);
+extern PyStatus _PyPreCmdline_SetConfig(
+    const _PyPreCmdline *cmdline,
+    PyConfig *config);
+extern PyStatus _PyPreCmdline_Read(_PyPreCmdline *cmdline,
+    const PyPreConfig *preconfig);
+
+
+/* --- PyPreConfig ----------------------------------------------- */
+
+PyAPI_FUNC(void) _PyPreConfig_InitCompatConfig(PyPreConfig *preconfig);
+extern void _PyPreConfig_InitFromConfig(
+    PyPreConfig *preconfig,
+    const PyConfig *config);
+extern PyStatus _PyPreConfig_InitFromPreConfig(
+    PyPreConfig *preconfig,
+    const PyPreConfig *config2);
+extern PyObject* _PyPreConfig_AsDict(const PyPreConfig *preconfig);
+extern void _PyPreConfig_GetConfig(PyPreConfig *preconfig,
+    const PyConfig *config);
+extern PyStatus _PyPreConfig_Read(PyPreConfig *preconfig,
+    const _PyArgv *args);
+extern PyStatus _PyPreConfig_Write(const PyPreConfig *preconfig);
+
+
+/* --- PyConfig ---------------------------------------------- */
+
+typedef enum {
+    /* Py_Initialize() API: backward compatibility with Python 3.6 and 3.7 */
+    _PyConfig_INIT_COMPAT = 1,
+    _PyConfig_INIT_PYTHON = 2,
+    _PyConfig_INIT_ISOLATED = 3
+} _PyConfigInitEnum;
+
+PyAPI_FUNC(void) _PyConfig_InitCompatConfig(PyConfig *config);
+extern PyStatus _PyConfig_Copy(
+    PyConfig *config,
+    const PyConfig *config2);
+extern PyStatus _PyConfig_InitPathConfig(PyConfig *config);
+extern PyStatus _PyConfig_Write(const PyConfig *config,
+    struct pyruntimestate *runtime);
+extern PyStatus _PyConfig_SetPyArgv(
+    PyConfig *config,
+    const _PyArgv *args);
+
+extern int _Py_global_config_int_max_str_digits;
+
+
+/* --- Function used for testing ---------------------------------- */
+
+PyAPI_FUNC(PyObject*) _Py_GetConfigsAsDict(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_CORECONFIG_H */
diff --git a/marketing/include/internal/pycore_interp.h b/marketing/include/internal/pycore_interp.h
new file mode 100644
index 0000000000000000000000000000000000000000..304d704a2c1c2b00e1efc7a5e6f5d6f41837863e
--- /dev/null
+++ b/marketing/include/internal/pycore_interp.h
@@ -0,0 +1,194 @@
+#ifndef Py_INTERNAL_INTERP_H
+#define Py_INTERNAL_INTERP_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "pycore_atomic.h"    /* _Py_atomic_address */
+#include "pycore_gil.h"       /* struct _gil_runtime_state  */
+#include "pycore_gc.h"        /* struct _gc_runtime_state */
+#include "pycore_warnings.h"  /* struct _warnings_runtime_state */
+
+/* ceval state */
+
+struct _pending_calls {
+    PyThread_type_lock lock;
+    /* Request for running pending calls. */
+    _Py_atomic_int calls_to_do;
+    /* Request for looking at the `async_exc` field of the current
+       thread state.
+       Guarded by the GIL. */
+    int async_exc;
+#define NPENDINGCALLS 32
+    struct {
+        int (*func)(void *);
+        void *arg;
+    } calls[NPENDINGCALLS];
+    int first;
+    int last;
+};
+
+struct _ceval_state {
+    int recursion_limit;
+    /* Records whether tracing is on for any thread.  Counts the number
+       of threads for which tstate->c_tracefunc is non-NULL, so if the
+       value is 0, we know we don't have to check this thread's
+       c_tracefunc.  This speeds up the if statement in
+       _PyEval_EvalFrameDefault() after fast_next_opcode. */
+    int tracing_possible;
+    /* This single variable consolidates all requests to break out of
+       the fast path in the eval loop. */
+    _Py_atomic_int eval_breaker;
+    /* Request for dropping the GIL */
+    _Py_atomic_int gil_drop_request;
+    struct _pending_calls pending;
+};
+
+/* fs_codec.encoding is initialized to NULL.
+   Later, it is set to a non-NULL string by _PyUnicode_InitEncodings(). */
+struct _Py_unicode_fs_codec {
+    char *encoding;   // Filesystem encoding (encoded to UTF-8)
+    int utf8;         // encoding=="utf-8"?
+    char *errors;     // Filesystem errors (encoded to UTF-8)
+    _Py_error_handler error_handler;
+};
+
+struct _Py_unicode_state {
+    struct _Py_unicode_fs_codec fs_codec;
+};
+
+
+/* interpreter state */
+
+#define _PY_NSMALLPOSINTS           257
+#define _PY_NSMALLNEGINTS           5
+
+// The PyInterpreterState typedef is in Include/pystate.h.
+struct _is {
+
+    struct _is *next;
+    struct _ts *tstate_head;
+
+    /* Reference to the _PyRuntime global variable. This field exists
+       to not have to pass runtime in addition to tstate to a function.
+       Get runtime from tstate: tstate->interp->runtime. */
+    struct pyruntimestate *runtime;
+
+    int64_t id;
+    int64_t id_refcount;
+    int requires_idref;
+    PyThread_type_lock id_mutex;
+
+    int finalizing;
+
+    struct _ceval_state ceval;
+    struct _gc_runtime_state gc;
+
+    PyObject *modules;
+    PyObject *modules_by_index;
+    PyObject *sysdict;
+    PyObject *builtins;
+    PyObject *importlib;
+
+    /* Used in Modules/_threadmodule.c. */
+    long num_threads;
+    /* Support for runtime thread stack size tuning.
+       A value of 0 means using the platform's default stack size
+       or the size specified by the THREAD_STACK_SIZE macro. */
+    /* Used in Python/thread.c. */
+    size_t pythread_stacksize;
+
+    PyObject *codec_search_path;
+    PyObject *codec_search_cache;
+    PyObject *codec_error_registry;
+    int codecs_initialized;
+
+    struct _Py_unicode_state unicode;
+
+    PyConfig config;
+#ifdef HAVE_DLOPEN
+    int dlopenflags;
+#endif
+
+    PyObject *dict;  /* Stores per-interpreter state */
+
+    PyObject *builtins_copy;
+    PyObject *import_func;
+    /* Initialized to PyEval_EvalFrameDefault(). */
+    _PyFrameEvalFunction eval_frame;
+
+    Py_ssize_t co_extra_user_count;
+    freefunc co_extra_freefuncs[MAX_CO_EXTRA_USERS];
+
+#ifdef HAVE_FORK
+    PyObject *before_forkers;
+    PyObject *after_forkers_parent;
+    PyObject *after_forkers_child;
+#endif
+    /* AtExit module */
+    void (*pyexitfunc)(PyObject *);
+    PyObject *pyexitmodule;
+
+    uint64_t tstate_next_unique_id;
+
+    struct _warnings_runtime_state warnings;
+
+    PyObject *audit_hooks;
+
+    struct {
+        struct {
+            int level;
+            int atbol;
+        } listnode;
+    } parser;
+
+#if _PY_NSMALLNEGINTS + _PY_NSMALLPOSINTS > 0
+    /* Small integers are preallocated in this array so that they
+       can be shared.
+       The integers that are preallocated are those in the range
+       -_PY_NSMALLNEGINTS (inclusive) to _PY_NSMALLPOSINTS (not inclusive).
+    */
+    PyLongObject* small_ints[_PY_NSMALLNEGINTS + _PY_NSMALLPOSINTS];
+#endif
+
+    int int_max_str_digits;
+};
+
+/* Used by _PyImport_Cleanup() */
+extern void _PyInterpreterState_ClearModules(PyInterpreterState *interp);
+
+extern PyStatus _PyInterpreterState_SetConfig(
+    PyInterpreterState *interp,
+    const PyConfig *config);
+
+
+
+/* cross-interpreter data registry */
+
+/* For now we use a global registry of shareable classes.  An
+   alternative would be to add a tp_* slot for a class's
+   crossinterpdatafunc. It would be simpler and more efficient. */
+
+struct _xidregitem;
+
+struct _xidregitem {
+    PyTypeObject *cls;
+    crossinterpdatafunc getdata;
+    struct _xidregitem *next;
+};
+
+PyAPI_FUNC(struct _is*) _PyInterpreterState_LookUpID(int64_t);
+
+PyAPI_FUNC(int) _PyInterpreterState_IDInitref(struct _is *);
+PyAPI_FUNC(void) _PyInterpreterState_IDIncref(struct _is *);
+PyAPI_FUNC(void) _PyInterpreterState_IDDecref(struct _is *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_INTERP_H */
+
diff --git a/marketing/include/internal/pycore_long.h b/marketing/include/internal/pycore_long.h
new file mode 100644
index 0000000000000000000000000000000000000000..ae04332a7a84cef03245448cc303e054921e29c6
--- /dev/null
+++ b/marketing/include/internal/pycore_long.h
@@ -0,0 +1,49 @@
+#ifndef Py_INTERNAL_LONG_H
+#define Py_INTERNAL_LONG_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/*
+ * Default int base conversion size limitation: Denial of Service prevention.
+ *
+ * Chosen such that this isn't wildly slow on modern hardware and so that
+ * everyone's existing deployed numpy test suite passes before
+ * https://github.com/numpy/numpy/issues/22098 is widely available.
+ *
+ * $ python -m timeit -s 's = "1"*4300' 'int(s)'
+ * 2000 loops, best of 5: 125 usec per loop
+ * $ python -m timeit -s 's = "1"*4300; v = int(s)' 'str(v)'
+ * 1000 loops, best of 5: 311 usec per loop
+ * (zen2 cloud VM)
+ *
+ * 4300 decimal digits fits a ~14284 bit number.
+ */
+#define _PY_LONG_DEFAULT_MAX_STR_DIGITS 4300
+/*
+ * Threshold for max digits check.  For performance reasons int() and
+ * int.__str__() don't checks values that are smaller than this
+ * threshold.  Acts as a guaranteed minimum size limit for bignums that
+ * applications can expect from CPython.
+ *
+ * % python -m timeit -s 's = "1"*640; v = int(s)' 'str(int(s))'
+ * 20000 loops, best of 5: 12 usec per loop
+ *
+ * "640 digits should be enough for anyone." - gps
+ * fits a ~2126 bit decimal number.
+ */
+#define _PY_LONG_MAX_STR_DIGITS_THRESHOLD 640
+
+#if ((_PY_LONG_DEFAULT_MAX_STR_DIGITS != 0) && \
+   (_PY_LONG_DEFAULT_MAX_STR_DIGITS < _PY_LONG_MAX_STR_DIGITS_THRESHOLD))
+# error "_PY_LONG_DEFAULT_MAX_STR_DIGITS smaller than threshold."
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_LONG_H */
diff --git a/marketing/include/internal/pycore_object.h b/marketing/include/internal/pycore_object.h
new file mode 100644
index 0000000000000000000000000000000000000000..c66ff12d7ec5a791f30541154ad72155ce9564bb
--- /dev/null
+++ b/marketing/include/internal/pycore_object.h
@@ -0,0 +1,123 @@
+#ifndef Py_INTERNAL_OBJECT_H
+#define Py_INTERNAL_OBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "pycore_gc.h"         // _PyObject_GC_IS_TRACKED()
+#include "pycore_interp.h"     // PyInterpreterState.gc
+#include "pycore_pystate.h"    // _PyThreadState_GET()
+
+PyAPI_FUNC(int) _PyType_CheckConsistency(PyTypeObject *type);
+PyAPI_FUNC(int) _PyDict_CheckConsistency(PyObject *mp, int check_content);
+
+/* Only private in Python 3.10 and 3.9.8+; public in 3.11 */
+extern PyObject *_PyType_GetQualName(PyTypeObject *type);
+
+/* Tell the GC to track this object.
+ *
+ * NB: While the object is tracked by the collector, it must be safe to call the
+ * ob_traverse method.
+ *
+ * Internal note: interp->gc.generation0->_gc_prev doesn't have any bit flags
+ * because it's not object header.  So we don't use _PyGCHead_PREV() and
+ * _PyGCHead_SET_PREV() for it to avoid unnecessary bitwise operations.
+ *
+ * The PyObject_GC_Track() function is the public version of this macro.
+ */
+static inline void _PyObject_GC_TRACK_impl(const char *filename, int lineno,
+                                           PyObject *op)
+{
+    _PyObject_ASSERT_FROM(op, !_PyObject_GC_IS_TRACKED(op),
+                          "object already tracked by the garbage collector",
+                          filename, lineno, "_PyObject_GC_TRACK");
+
+    PyGC_Head *gc = _Py_AS_GC(op);
+    _PyObject_ASSERT_FROM(op,
+                          (gc->_gc_prev & _PyGC_PREV_MASK_COLLECTING) == 0,
+                          "object is in generation which is garbage collected",
+                          filename, lineno, "_PyObject_GC_TRACK");
+
+    PyThreadState *tstate = _PyThreadState_GET();
+    PyGC_Head *generation0 = tstate->interp->gc.generation0;
+    PyGC_Head *last = (PyGC_Head*)(generation0->_gc_prev);
+    _PyGCHead_SET_NEXT(last, gc);
+    _PyGCHead_SET_PREV(gc, last);
+    _PyGCHead_SET_NEXT(gc, generation0);
+    generation0->_gc_prev = (uintptr_t)gc;
+}
+
+#define _PyObject_GC_TRACK(op) \
+    _PyObject_GC_TRACK_impl(__FILE__, __LINE__, _PyObject_CAST(op))
+
+/* Tell the GC to stop tracking this object.
+ *
+ * Internal note: This may be called while GC. So _PyGC_PREV_MASK_COLLECTING
+ * must be cleared. But _PyGC_PREV_MASK_FINALIZED bit is kept.
+ *
+ * The object must be tracked by the GC.
+ *
+ * The PyObject_GC_UnTrack() function is the public version of this macro.
+ */
+static inline void _PyObject_GC_UNTRACK_impl(const char *filename, int lineno,
+                                             PyObject *op)
+{
+    _PyObject_ASSERT_FROM(op, _PyObject_GC_IS_TRACKED(op),
+                          "object not tracked by the garbage collector",
+                          filename, lineno, "_PyObject_GC_UNTRACK");
+
+    PyGC_Head *gc = _Py_AS_GC(op);
+    PyGC_Head *prev = _PyGCHead_PREV(gc);
+    PyGC_Head *next = _PyGCHead_NEXT(gc);
+    _PyGCHead_SET_NEXT(prev, next);
+    _PyGCHead_SET_PREV(next, prev);
+    gc->_gc_next = 0;
+    gc->_gc_prev &= _PyGC_PREV_MASK_FINALIZED;
+}
+
+#define _PyObject_GC_UNTRACK(op) \
+    _PyObject_GC_UNTRACK_impl(__FILE__, __LINE__, _PyObject_CAST(op))
+
+#ifdef Py_REF_DEBUG
+extern void _PyDebug_PrintTotalRefs(void);
+#endif
+
+#ifdef Py_TRACE_REFS
+extern void _Py_AddToAllObjects(PyObject *op, int force);
+extern void _Py_PrintReferences(FILE *);
+extern void _Py_PrintReferenceAddresses(FILE *);
+#endif
+
+static inline PyObject **
+_PyObject_GET_WEAKREFS_LISTPTR(PyObject *op)
+{
+    Py_ssize_t offset = Py_TYPE(op)->tp_weaklistoffset;
+    return (PyObject **)((char *)op + offset);
+}
+
+// Fast inlined version of PyType_HasFeature()
+static inline int
+_PyType_HasFeature(PyTypeObject *type, unsigned long feature) {
+    return ((type->tp_flags & feature) != 0);
+}
+
+// Fast inlined version of PyObject_IS_GC()
+static inline int
+_PyObject_IS_GC(PyObject *obj)
+{
+    return (PyType_IS_GC(Py_TYPE(obj))
+            && (Py_TYPE(obj)->tp_is_gc == NULL
+                || Py_TYPE(obj)->tp_is_gc(obj)));
+}
+
+// Fast inlined version of PyType_IS_GC()
+#define _PyType_IS_GC(t) _PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_OBJECT_H */
diff --git a/marketing/include/internal/pycore_pathconfig.h b/marketing/include/internal/pycore_pathconfig.h
new file mode 100644
index 0000000000000000000000000000000000000000..42d61b1ca26bdfd0d6715192383271591e796f11
--- /dev/null
+++ b/marketing/include/internal/pycore_pathconfig.h
@@ -0,0 +1,72 @@
+#ifndef Py_INTERNAL_PATHCONFIG_H
+#define Py_INTERNAL_PATHCONFIG_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+typedef struct _PyPathConfig {
+    /* Full path to the Python program */
+    wchar_t *program_full_path;
+    wchar_t *prefix;
+    wchar_t *exec_prefix;
+    /* Set by Py_SetPath(), or computed by _PyConfig_InitPathConfig() */
+    wchar_t *module_search_path;
+    /* Python program name */
+    wchar_t *program_name;
+    /* Set by Py_SetPythonHome() or PYTHONHOME environment variable */
+    wchar_t *home;
+#ifdef MS_WINDOWS
+    /* isolated and site_import are used to set Py_IsolatedFlag and
+       Py_NoSiteFlag flags on Windows in read_pth_file(). These fields
+       are ignored when their value are equal to -1 (unset). */
+    int isolated;
+    int site_import;
+    /* Set when a venv is detected */
+    wchar_t *base_executable;
+#endif
+} _PyPathConfig;
+
+#ifdef MS_WINDOWS
+#  define _PyPathConfig_INIT \
+      {.module_search_path = NULL, \
+       .isolated = -1, \
+       .site_import = -1}
+#else
+#  define _PyPathConfig_INIT \
+      {.module_search_path = NULL}
+#endif
+/* Note: _PyPathConfig_INIT sets other fields to 0/NULL */
+
+PyAPI_DATA(_PyPathConfig) _Py_path_config;
+#ifdef MS_WINDOWS
+PyAPI_DATA(wchar_t*) _Py_dll_path;
+#endif
+
+extern void _PyPathConfig_ClearGlobal(void);
+
+extern PyStatus _PyPathConfig_Calculate(
+    _PyPathConfig *pathconfig,
+    const PyConfig *config);
+extern int _PyPathConfig_ComputeSysPath0(
+    const PyWideStringList *argv,
+    PyObject **path0);
+extern PyStatus _Py_FindEnvConfigValue(
+    FILE *env_file,
+    const wchar_t *key,
+    wchar_t **value_p);
+
+#ifdef MS_WINDOWS
+extern wchar_t* _Py_GetDLLPath(void);
+#endif
+
+extern PyStatus _PyConfig_WritePathConfig(const PyConfig *config);
+extern void _Py_DumpPathConfig(PyThreadState *tstate);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_PATHCONFIG_H */
diff --git a/marketing/include/internal/pycore_pyerrors.h b/marketing/include/internal/pycore_pyerrors.h
new file mode 100644
index 0000000000000000000000000000000000000000..2cf1160afc01490621d828108acc7afcb1ec30f2
--- /dev/null
+++ b/marketing/include/internal/pycore_pyerrors.h
@@ -0,0 +1,90 @@
+#ifndef Py_INTERNAL_PYERRORS_H
+#define Py_INTERNAL_PYERRORS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+static inline PyObject* _PyErr_Occurred(PyThreadState *tstate)
+{
+    assert(tstate != NULL);
+    return tstate->curexc_type;
+}
+
+static inline void _PyErr_ClearExcState(_PyErr_StackItem *exc_state)
+{
+    PyObject *t, *v, *tb;
+    t = exc_state->exc_type;
+    v = exc_state->exc_value;
+    tb = exc_state->exc_traceback;
+    exc_state->exc_type = NULL;
+    exc_state->exc_value = NULL;
+    exc_state->exc_traceback = NULL;
+    Py_XDECREF(t);
+    Py_XDECREF(v);
+    Py_XDECREF(tb);
+}
+
+
+PyAPI_FUNC(void) _PyErr_Fetch(
+    PyThreadState *tstate,
+    PyObject **type,
+    PyObject **value,
+    PyObject **traceback);
+
+PyAPI_FUNC(int) _PyErr_ExceptionMatches(
+    PyThreadState *tstate,
+    PyObject *exc);
+
+PyAPI_FUNC(void) _PyErr_Restore(
+    PyThreadState *tstate,
+    PyObject *type,
+    PyObject *value,
+    PyObject *traceback);
+
+PyAPI_FUNC(void) _PyErr_SetObject(
+    PyThreadState *tstate,
+    PyObject *type,
+    PyObject *value);
+
+PyAPI_FUNC(void) _PyErr_ChainStackItem(
+    _PyErr_StackItem *exc_info);
+
+PyAPI_FUNC(void) _PyErr_Clear(PyThreadState *tstate);
+
+PyAPI_FUNC(void) _PyErr_SetNone(PyThreadState *tstate, PyObject *exception);
+
+PyAPI_FUNC(PyObject *) _PyErr_NoMemory(PyThreadState *tstate);
+
+PyAPI_FUNC(void) _PyErr_SetString(
+    PyThreadState *tstate,
+    PyObject *exception,
+    const char *string);
+
+PyAPI_FUNC(PyObject *) _PyErr_Format(
+    PyThreadState *tstate,
+    PyObject *exception,
+    const char *format,
+    ...);
+
+PyAPI_FUNC(void) _PyErr_NormalizeException(
+    PyThreadState *tstate,
+    PyObject **exc,
+    PyObject **val,
+    PyObject **tb);
+
+PyAPI_FUNC(PyObject *) _PyErr_FormatFromCauseTstate(
+    PyThreadState *tstate,
+    PyObject *exception,
+    const char *format,
+    ...);
+
+PyAPI_FUNC(int) _PyErr_CheckSignalsTstate(PyThreadState *tstate);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_PYERRORS_H */
diff --git a/marketing/include/internal/pycore_pyhash.h b/marketing/include/internal/pycore_pyhash.h
new file mode 100644
index 0000000000000000000000000000000000000000..a229f8d8b7f0a2ab0bf9120fcc301cc5c74594c8
--- /dev/null
+++ b/marketing/include/internal/pycore_pyhash.h
@@ -0,0 +1,10 @@
+#ifndef Py_INTERNAL_HASH_H
+#define Py_INTERNAL_HASH_H
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+uint64_t _Py_KeyedHash(uint64_t, const char *, Py_ssize_t);
+
+#endif
diff --git a/marketing/include/internal/pycore_pylifecycle.h b/marketing/include/internal/pycore_pylifecycle.h
new file mode 100644
index 0000000000000000000000000000000000000000..50ab645fc7485973e41201d764de3653227ae50d
--- /dev/null
+++ b/marketing/include/internal/pycore_pylifecycle.h
@@ -0,0 +1,114 @@
+#ifndef Py_INTERNAL_LIFECYCLE_H
+#define Py_INTERNAL_LIFECYCLE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/* Forward declarations */
+struct _PyArgv;
+struct pyruntimestate;
+
+/* True if the main interpreter thread exited due to an unhandled
+ * KeyboardInterrupt exception, suggesting the user pressed ^C. */
+PyAPI_DATA(int) _Py_UnhandledKeyboardInterrupt;
+
+extern int _Py_SetFileSystemEncoding(
+    const char *encoding,
+    const char *errors);
+extern void _Py_ClearFileSystemEncoding(void);
+extern PyStatus _PyUnicode_InitEncodings(PyThreadState *tstate);
+#ifdef MS_WINDOWS
+extern int _PyUnicode_EnableLegacyWindowsFSEncoding(void);
+#endif
+
+PyAPI_FUNC(void) _Py_ClearStandardStreamEncoding(void);
+
+PyAPI_FUNC(int) _Py_IsLocaleCoercionTarget(const char *ctype_loc);
+
+/* Various one-time initializers */
+
+extern PyStatus _PyUnicode_Init(void);
+extern int _PyStructSequence_Init(void);
+extern int _PyLong_Init(PyThreadState *tstate);
+extern PyStatus _PyFaulthandler_Init(int enable);
+extern int _PyTraceMalloc_Init(int enable);
+extern PyObject * _PyBuiltin_Init(PyThreadState *tstate);
+extern PyStatus _PySys_Create(
+    PyThreadState *tstate,
+    PyObject **sysmod_p);
+extern PyStatus _PySys_ReadPreinitWarnOptions(PyWideStringList *options);
+extern PyStatus _PySys_ReadPreinitXOptions(PyConfig *config);
+extern int _PySys_InitMain(PyThreadState *tstate);
+extern PyStatus _PyExc_Init(void);
+extern PyStatus _PyErr_Init(void);
+extern PyStatus _PyBuiltins_AddExceptions(PyObject * bltinmod);
+extern PyStatus _PyImportHooks_Init(PyThreadState *tstate);
+extern int _PyFloat_Init(void);
+extern PyStatus _Py_HashRandomization_Init(const PyConfig *);
+
+extern PyStatus _PyTypes_Init(void);
+extern PyStatus _PyTypes_InitSlotDefs(void);
+extern PyStatus _PyImportZip_Init(PyThreadState *tstate);
+extern PyStatus _PyGC_Init(PyThreadState *tstate);
+
+
+/* Various internal finalizers */
+
+extern void _PyFrame_Fini(void);
+extern void _PyDict_Fini(void);
+extern void _PyTuple_Fini(void);
+extern void _PyList_Fini(void);
+extern void _PySet_Fini(void);
+extern void _PyBytes_Fini(void);
+extern void _PyFloat_Fini(void);
+extern void _PySlice_Fini(void);
+extern void _PyAsyncGen_Fini(void);
+
+extern int _PySignal_Init(int install_signal_handlers);
+extern void PyOS_FiniInterrupts(void);
+
+extern void _PyExc_Fini(void);
+extern void _PyImport_Fini(void);
+extern void _PyImport_Fini2(void);
+extern void _PyGC_Fini(PyThreadState *tstate);
+extern void _PyType_Fini(void);
+extern void _Py_HashRandomization_Fini(void);
+extern void _PyUnicode_Fini(PyThreadState *tstate);
+extern void _PyLong_Fini(PyThreadState *tstate);
+extern void _PyFaulthandler_Fini(void);
+extern void _PyHash_Fini(void);
+extern void _PyTraceMalloc_Fini(void);
+extern void _PyWarnings_Fini(PyInterpreterState *interp);
+extern void _PyAST_Fini(void);
+
+extern PyStatus _PyGILState_Init(PyThreadState *tstate);
+extern void _PyGILState_Fini(PyThreadState *tstate);
+
+PyAPI_FUNC(void) _PyGC_DumpShutdownStats(PyThreadState *tstate);
+
+PyAPI_FUNC(PyStatus) _Py_PreInitializeFromPyArgv(
+    const PyPreConfig *src_config,
+    const struct _PyArgv *args);
+PyAPI_FUNC(PyStatus) _Py_PreInitializeFromConfig(
+    const PyConfig *config,
+    const struct _PyArgv *args);
+
+
+PyAPI_FUNC(int) _Py_HandleSystemExit(int *exitcode_p);
+
+PyAPI_FUNC(PyObject*) _PyErr_WriteUnraisableDefaultHook(PyObject *unraisable);
+
+PyAPI_FUNC(void) _PyErr_Print(PyThreadState *tstate);
+PyAPI_FUNC(void) _PyErr_Display(PyObject *file, PyObject *exception,
+                                PyObject *value, PyObject *tb);
+
+PyAPI_FUNC(void) _PyThreadState_DeleteCurrent(PyThreadState *tstate);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_LIFECYCLE_H */
diff --git a/marketing/include/internal/pycore_pymem.h b/marketing/include/internal/pycore_pymem.h
new file mode 100644
index 0000000000000000000000000000000000000000..9bcb5f5efd742964d31f3d477ded029a60c757cd
--- /dev/null
+++ b/marketing/include/internal/pycore_pymem.h
@@ -0,0 +1,104 @@
+#ifndef Py_INTERNAL_PYMEM_H
+#define Py_INTERNAL_PYMEM_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "pymem.h"      // PyMemAllocatorName
+
+
+/* Set the memory allocator of the specified domain to the default.
+   Save the old allocator into *old_alloc if it's non-NULL.
+   Return on success, or return -1 if the domain is unknown. */
+PyAPI_FUNC(int) _PyMem_SetDefaultAllocator(
+    PyMemAllocatorDomain domain,
+    PyMemAllocatorEx *old_alloc);
+
+/* Special bytes broadcast into debug memory blocks at appropriate times.
+   Strings of these are unlikely to be valid addresses, floats, ints or
+   7-bit ASCII.
+
+   - PYMEM_CLEANBYTE: clean (newly allocated) memory
+   - PYMEM_DEADBYTE dead (newly freed) memory
+   - PYMEM_FORBIDDENBYTE: untouchable bytes at each end of a block
+
+   Byte patterns 0xCB, 0xDB and 0xFB have been replaced with 0xCD, 0xDD and
+   0xFD to use the same values than Windows CRT debug malloc() and free().
+   If modified, _PyMem_IsPtrFreed() should be updated as well. */
+#define PYMEM_CLEANBYTE      0xCD
+#define PYMEM_DEADBYTE       0xDD
+#define PYMEM_FORBIDDENBYTE  0xFD
+
+/* Heuristic checking if a pointer value is newly allocated
+   (uninitialized), newly freed or NULL (is equal to zero).
+
+   The pointer is not dereferenced, only the pointer value is checked.
+
+   The heuristic relies on the debug hooks on Python memory allocators which
+   fills newly allocated memory with CLEANBYTE (0xCD) and newly freed memory
+   with DEADBYTE (0xDD). Detect also "untouchable bytes" marked
+   with FORBIDDENBYTE (0xFD). */
+static inline int _PyMem_IsPtrFreed(const void *ptr)
+{
+    uintptr_t value = (uintptr_t)ptr;
+#if SIZEOF_VOID_P == 8
+    return (value == 0
+            || value == (uintptr_t)0xCDCDCDCDCDCDCDCD
+            || value == (uintptr_t)0xDDDDDDDDDDDDDDDD
+            || value == (uintptr_t)0xFDFDFDFDFDFDFDFD);
+#elif SIZEOF_VOID_P == 4
+    return (value == 0
+            || value == (uintptr_t)0xCDCDCDCD
+            || value == (uintptr_t)0xDDDDDDDD
+            || value == (uintptr_t)0xFDFDFDFD);
+#else
+#  error "unknown pointer size"
+#endif
+}
+
+PyAPI_FUNC(int) _PyMem_GetAllocatorName(
+    const char *name,
+    PyMemAllocatorName *allocator);
+
+/* Configure the Python memory allocators.
+   Pass PYMEM_ALLOCATOR_DEFAULT to use default allocators.
+   PYMEM_ALLOCATOR_NOT_SET does nothing. */
+PyAPI_FUNC(int) _PyMem_SetupAllocators(PyMemAllocatorName allocator);
+
+/* bpo-35053: Expose _Py_tracemalloc_config for _Py_NewReference()
+   which access directly _Py_tracemalloc_config.tracing for best
+   performances. */
+struct _PyTraceMalloc_Config {
+    /* Module initialized?
+       Variable protected by the GIL */
+    enum {
+        TRACEMALLOC_NOT_INITIALIZED,
+        TRACEMALLOC_INITIALIZED,
+        TRACEMALLOC_FINALIZED
+    } initialized;
+
+    /* Is tracemalloc tracing memory allocations?
+       Variable protected by the GIL */
+    int tracing;
+
+    /* limit of the number of frames in a traceback, 1 by default.
+       Variable protected by the GIL. */
+    int max_nframe;
+};
+
+#define _PyTraceMalloc_Config_INIT \
+    {.initialized = TRACEMALLOC_NOT_INITIALIZED, \
+     .tracing = 0, \
+     .max_nframe = 1}
+
+PyAPI_DATA(struct _PyTraceMalloc_Config) _Py_tracemalloc_config;
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_PYMEM_H */
diff --git a/marketing/include/internal/pycore_pystate.h b/marketing/include/internal/pycore_pystate.h
new file mode 100644
index 0000000000000000000000000000000000000000..835d6e029c44988acf7721452320c8bd97f9b7b5
--- /dev/null
+++ b/marketing/include/internal/pycore_pystate.h
@@ -0,0 +1,138 @@
+#ifndef Py_INTERNAL_PYSTATE_H
+#define Py_INTERNAL_PYSTATE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "pycore_runtime.h"   /* PyRuntimeState */
+
+
+/* Check if the current thread is the main thread.
+   Use _Py_IsMainInterpreter() to check if it's the main interpreter. */
+static inline int
+_Py_IsMainThread(void)
+{
+    unsigned long thread = PyThread_get_thread_ident();
+    return (thread == _PyRuntime.main_thread);
+}
+
+
+static inline int
+_Py_IsMainInterpreter(PyThreadState* tstate)
+{
+    /* Use directly _PyRuntime rather than tstate->interp->runtime, since
+       this function is used in performance critical code path (ceval) */
+    return (tstate->interp == _PyRuntime.interpreters.main);
+}
+
+
+/* Only handle signals on the main thread of the main interpreter. */
+static inline int
+_Py_ThreadCanHandleSignals(PyInterpreterState *interp)
+{
+    return (_Py_IsMainThread() && interp == _PyRuntime.interpreters.main);
+}
+
+
+/* Only execute pending calls on the main thread. */
+static inline int
+_Py_ThreadCanHandlePendingCalls(void)
+{
+    return _Py_IsMainThread();
+}
+
+
+/* Variable and macro for in-line access to current thread
+   and interpreter state */
+
+static inline PyThreadState*
+_PyRuntimeState_GetThreadState(_PyRuntimeState *runtime)
+{
+    return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->gilstate.tstate_current);
+}
+
+/* Get the current Python thread state.
+
+   Efficient macro reading directly the 'gilstate.tstate_current' atomic
+   variable. The macro is unsafe: it does not check for error and it can
+   return NULL.
+
+   The caller must hold the GIL.
+
+   See also PyThreadState_Get() and PyThreadState_GET(). */
+static inline PyThreadState*
+_PyThreadState_GET(void)
+{
+    return _PyRuntimeState_GetThreadState(&_PyRuntime);
+}
+
+/* Redefine PyThreadState_GET() as an alias to _PyThreadState_GET() */
+#undef PyThreadState_GET
+#define PyThreadState_GET() _PyThreadState_GET()
+
+PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalError_TstateNULL(const char *func);
+
+static inline void
+_Py_EnsureFuncTstateNotNULL(const char *func, PyThreadState *tstate)
+{
+    if (tstate == NULL) {
+        _Py_FatalError_TstateNULL(func);
+    }
+}
+
+// Call Py_FatalError() if tstate is NULL
+#define _Py_EnsureTstateNotNULL(tstate) \
+    _Py_EnsureFuncTstateNotNULL(__func__, tstate)
+
+
+/* Get the current interpreter state.
+
+   The macro is unsafe: it does not check for error and it can return NULL.
+
+   The caller must hold the GIL.
+
+   See also _PyInterpreterState_Get()
+   and _PyGILState_GetInterpreterStateUnsafe(). */
+static inline PyInterpreterState* _PyInterpreterState_GET(void) {
+    PyThreadState *tstate = _PyThreadState_GET();
+#ifdef Py_DEBUG
+    _Py_EnsureTstateNotNULL(tstate);
+#endif
+    return tstate->interp;
+}
+
+
+/* Other */
+
+PyAPI_FUNC(void) _PyThreadState_Init(
+    PyThreadState *tstate);
+PyAPI_FUNC(void) _PyThreadState_DeleteExcept(
+    _PyRuntimeState *runtime,
+    PyThreadState *tstate);
+
+PyAPI_FUNC(PyThreadState *) _PyThreadState_Swap(
+    struct _gilstate_runtime_state *gilstate,
+    PyThreadState *newts);
+
+PyAPI_FUNC(PyStatus) _PyInterpreterState_Enable(_PyRuntimeState *runtime);
+PyAPI_FUNC(void) _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime);
+
+PyAPI_FUNC(void) _PyGILState_Reinit(_PyRuntimeState *runtime);
+
+
+PyAPI_FUNC(int) _PyState_AddModule(
+    PyThreadState *tstate,
+    PyObject* module,
+    struct PyModuleDef* def);
+
+
+PyAPI_FUNC(int) _PyOS_InterruptOccurred(PyThreadState *tstate);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_PYSTATE_H */
diff --git a/marketing/include/internal/pycore_runtime.h b/marketing/include/internal/pycore_runtime.h
new file mode 100644
index 0000000000000000000000000000000000000000..34eb492b9f254f8faabef434cebb252249ff07b3
--- /dev/null
+++ b/marketing/include/internal/pycore_runtime.h
@@ -0,0 +1,144 @@
+#ifndef Py_INTERNAL_RUNTIME_H
+#define Py_INTERNAL_RUNTIME_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "pycore_atomic.h"    /* _Py_atomic_address */
+#include "pycore_gil.h"       // struct _gil_runtime_state
+
+/* ceval state */
+
+struct _ceval_runtime_state {
+    /* Request for checking signals. It is shared by all interpreters (see
+       bpo-40513). Any thread of any interpreter can receive a signal, but only
+       the main thread of the main interpreter can handle signals: see
+       _Py_ThreadCanHandleSignals(). */
+    _Py_atomic_int signals_pending;
+    struct _gil_runtime_state gil;
+};
+
+/* GIL state */
+
+struct _gilstate_runtime_state {
+    /* bpo-26558: Flag to disable PyGILState_Check().
+       If set to non-zero, PyGILState_Check() always return 1. */
+    int check_enabled;
+    /* Assuming the current thread holds the GIL, this is the
+       PyThreadState for the current thread. */
+    _Py_atomic_address tstate_current;
+    /* The single PyInterpreterState used by this process'
+       GILState implementation
+    */
+    /* TODO: Given interp_main, it may be possible to kill this ref */
+    PyInterpreterState *autoInterpreterState;
+    Py_tss_t autoTSSkey;
+};
+
+/* Runtime audit hook state */
+
+typedef struct _Py_AuditHookEntry {
+    struct _Py_AuditHookEntry *next;
+    Py_AuditHookFunction hookCFunction;
+    void *userData;
+} _Py_AuditHookEntry;
+
+/* Full Python runtime state */
+
+typedef struct pyruntimestate {
+    /* Is running Py_PreInitialize()? */
+    int preinitializing;
+
+    /* Is Python preinitialized? Set to 1 by Py_PreInitialize() */
+    int preinitialized;
+
+    /* Is Python core initialized? Set to 1 by _Py_InitializeCore() */
+    int core_initialized;
+
+    /* Is Python fully initialized? Set to 1 by Py_Initialize() */
+    int initialized;
+
+    /* Set by Py_FinalizeEx(). Only reset to NULL if Py_Initialize()
+       is called again.
+
+       Use _PyRuntimeState_GetFinalizing() and _PyRuntimeState_SetFinalizing()
+       to access it, don't access it directly. */
+    _Py_atomic_address _finalizing;
+
+    struct pyinterpreters {
+        PyThread_type_lock mutex;
+        PyInterpreterState *head;
+        PyInterpreterState *main;
+        /* _next_interp_id is an auto-numbered sequence of small
+           integers.  It gets initialized in _PyInterpreterState_Init(),
+           which is called in Py_Initialize(), and used in
+           PyInterpreterState_New().  A negative interpreter ID
+           indicates an error occurred.  The main interpreter will
+           always have an ID of 0.  Overflow results in a RuntimeError.
+           If that becomes a problem later then we can adjust, e.g. by
+           using a Python int. */
+        int64_t next_id;
+    } interpreters;
+    // XXX Remove this field once we have a tp_* slot.
+    struct _xidregistry {
+        PyThread_type_lock mutex;
+        struct _xidregitem *head;
+    } xidregistry;
+
+    unsigned long main_thread;
+
+#define NEXITFUNCS 32
+    void (*exitfuncs[NEXITFUNCS])(void);
+    int nexitfuncs;
+
+    struct _ceval_runtime_state ceval;
+    struct _gilstate_runtime_state gilstate;
+
+    PyPreConfig preconfig;
+
+    Py_OpenCodeHookFunction open_code_hook;
+    void *open_code_userdata;
+    _Py_AuditHookEntry *audit_hook_head;
+
+    // XXX Consolidate globals found via the check-c-globals script.
+} _PyRuntimeState;
+
+#define _PyRuntimeState_INIT \
+    {.preinitialized = 0, .core_initialized = 0, .initialized = 0}
+/* Note: _PyRuntimeState_INIT sets other fields to 0/NULL */
+
+
+PyAPI_DATA(_PyRuntimeState) _PyRuntime;
+
+PyAPI_FUNC(PyStatus) _PyRuntimeState_Init(_PyRuntimeState *runtime);
+PyAPI_FUNC(void) _PyRuntimeState_Fini(_PyRuntimeState *runtime);
+
+#ifdef HAVE_FORK
+PyAPI_FUNC(void) _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime);
+#endif
+
+/* Initialize _PyRuntimeState.
+   Return NULL on success, or return an error message on failure. */
+PyAPI_FUNC(PyStatus) _PyRuntime_Initialize(void);
+
+PyAPI_FUNC(void) _PyRuntime_Finalize(void);
+
+
+static inline PyThreadState*
+_PyRuntimeState_GetFinalizing(_PyRuntimeState *runtime) {
+    return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->_finalizing);
+}
+
+static inline void
+_PyRuntimeState_SetFinalizing(_PyRuntimeState *runtime, PyThreadState *tstate) {
+    _Py_atomic_store_relaxed(&runtime->_finalizing, (uintptr_t)tstate);
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_RUNTIME_H */
diff --git a/marketing/include/internal/pycore_sysmodule.h b/marketing/include/internal/pycore_sysmodule.h
new file mode 100644
index 0000000000000000000000000000000000000000..738a7746a03842ed20feca6878339c95d878e960
--- /dev/null
+++ b/marketing/include/internal/pycore_sysmodule.h
@@ -0,0 +1,24 @@
+#ifndef Py_INTERNAL_SYSMODULE_H
+#define Py_INTERNAL_SYSMODULE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+PyAPI_FUNC(int) _PySys_Audit(
+    PyThreadState *tstate,
+    const char *event,
+    const char *argFormat,
+    ...);
+
+/* We want minimal exposure of this function, so use extern rather than
+   PyAPI_FUNC() to not export the symbol. */
+extern void _PySys_ClearAuditHooks(PyThreadState *tstate);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_SYSMODULE_H */
diff --git a/marketing/include/internal/pycore_traceback.h b/marketing/include/internal/pycore_traceback.h
new file mode 100644
index 0000000000000000000000000000000000000000..c23290ebec59924d148630e0ff3f18d6caaec8e0
--- /dev/null
+++ b/marketing/include/internal/pycore_traceback.h
@@ -0,0 +1,97 @@
+#ifndef Py_INTERNAL_TRACEBACK_H
+#define Py_INTERNAL_TRACEBACK_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+/* Forward declaration */
+struct _is;
+
+/* Write the Python traceback into the file 'fd'. For example:
+
+       Traceback (most recent call first):
+         File "xxx", line xxx in 
+         File "xxx", line xxx in 
+         ...
+         File "xxx", line xxx in 
+
+   This function is written for debug purpose only, to dump the traceback in
+   the worst case: after a segmentation fault, at fatal error, etc. That's why,
+   it is very limited. Strings are truncated to 100 characters and encoded to
+   ASCII with backslashreplace. It doesn't write the source code, only the
+   function name, filename and line number of each frame. Write only the first
+   100 frames: if the traceback is truncated, write the line " ...".
+
+   This function is signal safe. */
+
+PyAPI_FUNC(void) _Py_DumpTraceback(
+    int fd,
+    PyThreadState *tstate);
+
+/* Write the traceback of all threads into the file 'fd'. current_thread can be
+   NULL.
+
+   Return NULL on success, or an error message on error.
+
+   This function is written for debug purpose only. It calls
+   _Py_DumpTraceback() for each thread, and so has the same limitations. It
+   only write the traceback of the first 100 threads: write "..." if there are
+   more threads.
+
+   If current_tstate is NULL, the function tries to get the Python thread state
+   of the current thread. It is not an error if the function is unable to get
+   the current Python thread state.
+
+   If interp is NULL, the function tries to get the interpreter state from
+   the current Python thread state, or from
+   _PyGILState_GetInterpreterStateUnsafe() in last resort.
+
+   It is better to pass NULL to interp and current_tstate, the function tries
+   different options to retrieve this information.
+
+   This function is signal safe. */
+
+PyAPI_FUNC(const char*) _Py_DumpTracebackThreads(
+    int fd,
+    struct _is *interp,
+    PyThreadState *current_tstate);
+
+/* Write a Unicode object into the file descriptor fd. Encode the string to
+   ASCII using the backslashreplace error handler.
+
+   Do nothing if text is not a Unicode object. The function accepts Unicode
+   string which is not ready (PyUnicode_WCHAR_KIND).
+
+   This function is signal safe. */
+PyAPI_FUNC(void) _Py_DumpASCII(int fd, PyObject *text);
+
+/* Format an integer as decimal into the file descriptor fd.
+
+   This function is signal safe. */
+PyAPI_FUNC(void) _Py_DumpDecimal(
+    int fd,
+    unsigned long value);
+
+/* Format an integer as hexadecimal into the file descriptor fd with at least
+   width digits.
+
+   The maximum width is sizeof(unsigned long)*2 digits.
+
+   This function is signal safe. */
+PyAPI_FUNC(void) _Py_DumpHexadecimal(
+    int fd,
+    unsigned long value,
+    Py_ssize_t width);
+
+PyAPI_FUNC(PyObject*) _PyTraceBack_FromFrame(
+    PyObject *tb_next,
+    PyFrameObject *frame);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_TRACEBACK_H */
diff --git a/marketing/include/internal/pycore_tupleobject.h b/marketing/include/internal/pycore_tupleobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..f95f16c0ed02f2d201ea5809bbb604c048e03778
--- /dev/null
+++ b/marketing/include/internal/pycore_tupleobject.h
@@ -0,0 +1,19 @@
+#ifndef Py_INTERNAL_TUPLEOBJECT_H
+#define Py_INTERNAL_TUPLEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#include "tupleobject.h"   /* _PyTuple_CAST() */
+
+#define _PyTuple_ITEMS(op) (_PyTuple_CAST(op)->ob_item)
+PyAPI_FUNC(PyObject *) _PyTuple_FromArray(PyObject *const *, Py_ssize_t);
+
+#ifdef __cplusplus
+}
+#endif
+#endif   /* !Py_INTERNAL_TUPLEOBJECT_H */
diff --git a/marketing/include/internal/pycore_warnings.h b/marketing/include/internal/pycore_warnings.h
new file mode 100644
index 0000000000000000000000000000000000000000..cafe305edb0e02429926090d763857855c06a0a4
--- /dev/null
+++ b/marketing/include/internal/pycore_warnings.h
@@ -0,0 +1,25 @@
+#ifndef Py_INTERNAL_WARNINGS_H
+#define Py_INTERNAL_WARNINGS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+struct _warnings_runtime_state {
+    /* Both 'filters' and 'onceregistry' can be set in warnings.py;
+       get_warnings_attr() will reset these variables accordingly. */
+    PyObject *filters;  /* List */
+    PyObject *once_registry;  /* Dict */
+    PyObject *default_action; /* String */
+    long filters_version;
+};
+
+extern PyStatus _PyWarnings_InitState(PyThreadState *tstate);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_WARNINGS_H */
diff --git a/marketing/include/interpreteridobject.h b/marketing/include/interpreteridobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..e744fcdc9ff1899c825ac44009a59002f3990178
--- /dev/null
+++ b/marketing/include/interpreteridobject.h
@@ -0,0 +1,17 @@
+#ifndef Py_INTERPRETERIDOBJECT_H
+#define Py_INTERPRETERIDOBJECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_INTERPRETERIDOBJECT_H
+#  include  "cpython/interpreteridobject.h"
+#  undef Py_CPYTHON_INTERPRETERIDOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERPRETERIDOBJECT_H */
diff --git a/marketing/include/intrcheck.h b/marketing/include/intrcheck.h
new file mode 100644
index 0000000000000000000000000000000000000000..e5bf5a834e44c8edda0158255214abed8503a2a9
--- /dev/null
+++ b/marketing/include/intrcheck.h
@@ -0,0 +1,33 @@
+
+#ifndef Py_INTRCHECK_H
+#define Py_INTRCHECK_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(int) PyOS_InterruptOccurred(void);
+PyAPI_FUNC(void) PyOS_InitInterrupts(void);
+#ifdef HAVE_FORK
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
+PyAPI_FUNC(void) PyOS_BeforeFork(void);
+PyAPI_FUNC(void) PyOS_AfterFork_Parent(void);
+PyAPI_FUNC(void) PyOS_AfterFork_Child(void);
+#endif
+#endif
+/* Deprecated, please use PyOS_AfterFork_Child() instead */
+Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyOS_AfterFork(void);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(int) _PyOS_IsMainThread(void);
+PyAPI_FUNC(void) _PySignal_AfterFork(void);
+
+#ifdef MS_WINDOWS
+/* windows.h is not included by Python.h so use void* instead of HANDLE */
+PyAPI_FUNC(void*) _PyOS_SigintEvent(void);
+#endif
+#endif /* !Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTRCHECK_H */
diff --git a/marketing/include/iterobject.h b/marketing/include/iterobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..51139bf1874088965d0f341e442f653a2c5aae0f
--- /dev/null
+++ b/marketing/include/iterobject.h
@@ -0,0 +1,24 @@
+#ifndef Py_ITEROBJECT_H
+#define Py_ITEROBJECT_H
+/* Iterators (the basic kind, over a sequence) */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PySeqIter_Type;
+PyAPI_DATA(PyTypeObject) PyCallIter_Type;
+
+#define PySeqIter_Check(op) Py_IS_TYPE(op, &PySeqIter_Type)
+
+PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *);
+
+
+#define PyCallIter_Check(op) Py_IS_TYPE(op, &PyCallIter_Type)
+
+PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_ITEROBJECT_H */
+
diff --git a/marketing/include/listobject.h b/marketing/include/listobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a8a25525d1d7bf660ab7ed55592a4714ac6c5af
--- /dev/null
+++ b/marketing/include/listobject.h
@@ -0,0 +1,52 @@
+/* List object interface
+
+   Another generally useful object type is a list of object pointers.
+   This is a mutable type: the list items can be changed, and items can be
+   added or removed. Out-of-range indices or non-list objects are ignored.
+
+   WARNING: PyList_SetItem does not increment the new item's reference count,
+   but does decrement the reference count of the item it replaces, if not nil.
+   It does *decrement* the reference count if it is *not* inserted in the list.
+   Similarly, PyList_GetItem does not increment the returned item's reference
+   count.
+*/
+
+#ifndef Py_LISTOBJECT_H
+#define Py_LISTOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyList_Type;
+PyAPI_DATA(PyTypeObject) PyListIter_Type;
+PyAPI_DATA(PyTypeObject) PyListRevIter_Type;
+
+#define PyList_Check(op) \
+    PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS)
+#define PyList_CheckExact(op) Py_IS_TYPE(op, &PyList_Type)
+
+PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size);
+PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject *);
+
+PyAPI_FUNC(PyObject *) PyList_GetItem(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyList_SetItem(PyObject *, Py_ssize_t, PyObject *);
+PyAPI_FUNC(int) PyList_Insert(PyObject *, Py_ssize_t, PyObject *);
+PyAPI_FUNC(int) PyList_Append(PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
+PyAPI_FUNC(int) PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
+
+PyAPI_FUNC(int) PyList_Sort(PyObject *);
+PyAPI_FUNC(int) PyList_Reverse(PyObject *);
+PyAPI_FUNC(PyObject *) PyList_AsTuple(PyObject *);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_LISTOBJECT_H
+#  include  "cpython/listobject.h"
+#  undef Py_CPYTHON_LISTOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_LISTOBJECT_H */
diff --git a/marketing/include/longintrepr.h b/marketing/include/longintrepr.h
new file mode 100644
index 0000000000000000000000000000000000000000..ff4155f9656defa2bc7623ddb4ecee6f45564dfc
--- /dev/null
+++ b/marketing/include/longintrepr.h
@@ -0,0 +1,99 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_LONGINTREPR_H
+#define Py_LONGINTREPR_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* This is published for the benefit of "friends" marshal.c and _decimal.c. */
+
+/* Parameters of the integer representation.  There are two different
+   sets of parameters: one set for 30-bit digits, stored in an unsigned 32-bit
+   integer type, and one set for 15-bit digits with each digit stored in an
+   unsigned short.  The value of PYLONG_BITS_IN_DIGIT, defined either at
+   configure time or in pyport.h, is used to decide which digit size to use.
+
+   Type 'digit' should be able to hold 2*PyLong_BASE-1, and type 'twodigits'
+   should be an unsigned integer type able to hold all integers up to
+   PyLong_BASE*PyLong_BASE-1.  x_sub assumes that 'digit' is an unsigned type,
+   and that overflow is handled by taking the result modulo 2**N for some N >
+   PyLong_SHIFT.  The majority of the code doesn't care about the precise
+   value of PyLong_SHIFT, but there are some notable exceptions:
+
+   - long_pow() requires that PyLong_SHIFT be divisible by 5
+
+   - PyLong_{As,From}ByteArray require that PyLong_SHIFT be at least 8
+
+   - long_hash() requires that PyLong_SHIFT is *strictly* less than the number
+     of bits in an unsigned long, as do the PyLong <-> long (or unsigned long)
+     conversion functions
+
+   - the Python int <-> size_t/Py_ssize_t conversion functions expect that
+     PyLong_SHIFT is strictly less than the number of bits in a size_t
+
+   - the marshal code currently expects that PyLong_SHIFT is a multiple of 15
+
+   - NSMALLNEGINTS and NSMALLPOSINTS should be small enough to fit in a single
+     digit; with the current values this forces PyLong_SHIFT >= 9
+
+  The values 15 and 30 should fit all of the above requirements, on any
+  platform.
+*/
+
+#if PYLONG_BITS_IN_DIGIT == 30
+typedef uint32_t digit;
+typedef int32_t sdigit; /* signed variant of digit */
+typedef uint64_t twodigits;
+typedef int64_t stwodigits; /* signed variant of twodigits */
+#define PyLong_SHIFT    30
+#define _PyLong_DECIMAL_SHIFT   9 /* max(e such that 10**e fits in a digit) */
+#define _PyLong_DECIMAL_BASE    ((digit)1000000000) /* 10 ** DECIMAL_SHIFT */
+#elif PYLONG_BITS_IN_DIGIT == 15
+typedef unsigned short digit;
+typedef short sdigit; /* signed variant of digit */
+typedef unsigned long twodigits;
+typedef long stwodigits; /* signed variant of twodigits */
+#define PyLong_SHIFT    15
+#define _PyLong_DECIMAL_SHIFT   4 /* max(e such that 10**e fits in a digit) */
+#define _PyLong_DECIMAL_BASE    ((digit)10000) /* 10 ** DECIMAL_SHIFT */
+#else
+#error "PYLONG_BITS_IN_DIGIT should be 15 or 30"
+#endif
+#define PyLong_BASE     ((digit)1 << PyLong_SHIFT)
+#define PyLong_MASK     ((digit)(PyLong_BASE - 1))
+
+#if PyLong_SHIFT % 5 != 0
+#error "longobject.c requires that PyLong_SHIFT be divisible by 5"
+#endif
+
+/* Long integer representation.
+   The absolute value of a number is equal to
+        SUM(for i=0 through abs(ob_size)-1) ob_digit[i] * 2**(SHIFT*i)
+   Negative numbers are represented with ob_size < 0;
+   zero is represented by ob_size == 0.
+   In a normalized number, ob_digit[abs(ob_size)-1] (the most significant
+   digit) is never zero.  Also, in all cases, for all valid i,
+        0 <= ob_digit[i] <= MASK.
+   The allocation function takes care of allocating extra memory
+   so that ob_digit[0] ... ob_digit[abs(ob_size)-1] are actually available.
+
+   CAUTION:  Generic code manipulating subtypes of PyVarObject has to
+   aware that ints abuse  ob_size's sign bit.
+*/
+
+struct _longobject {
+    PyObject_VAR_HEAD
+    digit ob_digit[1];
+};
+
+PyAPI_FUNC(PyLongObject *) _PyLong_New(Py_ssize_t);
+
+/* Return a copy of src. */
+PyAPI_FUNC(PyObject *) _PyLong_Copy(PyLongObject *src);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_LONGINTREPR_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/longobject.h b/marketing/include/longobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b288099da8c837b7614f581b35d0e29564610d6
--- /dev/null
+++ b/marketing/include/longobject.h
@@ -0,0 +1,242 @@
+#ifndef Py_LONGOBJECT_H
+#define Py_LONGOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Long (arbitrary precision) integer object interface */
+
+typedef struct _longobject PyLongObject; /* Revealed in longintrepr.h */
+
+PyAPI_DATA(PyTypeObject) PyLong_Type;
+
+#define PyLong_Check(op) \
+        PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS)
+#define PyLong_CheckExact(op) Py_IS_TYPE(op, &PyLong_Type)
+
+PyAPI_FUNC(PyObject *) PyLong_FromLong(long);
+PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLong(unsigned long);
+PyAPI_FUNC(PyObject *) PyLong_FromSize_t(size_t);
+PyAPI_FUNC(PyObject *) PyLong_FromSsize_t(Py_ssize_t);
+PyAPI_FUNC(PyObject *) PyLong_FromDouble(double);
+PyAPI_FUNC(long) PyLong_AsLong(PyObject *);
+PyAPI_FUNC(long) PyLong_AsLongAndOverflow(PyObject *, int *);
+PyAPI_FUNC(Py_ssize_t) PyLong_AsSsize_t(PyObject *);
+PyAPI_FUNC(size_t) PyLong_AsSize_t(PyObject *);
+PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *);
+PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(int) _PyLong_AsInt(PyObject *);
+#endif
+PyAPI_FUNC(PyObject *) PyLong_GetInfo(void);
+
+/* It may be useful in the future. I've added it in the PyInt -> PyLong
+   cleanup to keep the extra information. [CH] */
+#define PyLong_AS_LONG(op) PyLong_AsLong(op)
+
+/* Issue #1983: pid_t can be longer than a C long on some systems */
+#if !defined(SIZEOF_PID_T) || SIZEOF_PID_T == SIZEOF_INT
+#define _Py_PARSE_PID "i"
+#define PyLong_FromPid PyLong_FromLong
+#define PyLong_AsPid PyLong_AsLong
+#elif SIZEOF_PID_T == SIZEOF_LONG
+#define _Py_PARSE_PID "l"
+#define PyLong_FromPid PyLong_FromLong
+#define PyLong_AsPid PyLong_AsLong
+#elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG
+#define _Py_PARSE_PID "L"
+#define PyLong_FromPid PyLong_FromLongLong
+#define PyLong_AsPid PyLong_AsLongLong
+#else
+#error "sizeof(pid_t) is neither sizeof(int), sizeof(long) or sizeof(long long)"
+#endif /* SIZEOF_PID_T */
+
+#if SIZEOF_VOID_P == SIZEOF_INT
+#  define _Py_PARSE_INTPTR "i"
+#  define _Py_PARSE_UINTPTR "I"
+#elif SIZEOF_VOID_P == SIZEOF_LONG
+#  define _Py_PARSE_INTPTR "l"
+#  define _Py_PARSE_UINTPTR "k"
+#elif defined(SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG
+#  define _Py_PARSE_INTPTR "L"
+#  define _Py_PARSE_UINTPTR "K"
+#else
+#  error "void* different in size from int, long and long long"
+#endif /* SIZEOF_VOID_P */
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(int) _PyLong_UnsignedShort_Converter(PyObject *, void *);
+PyAPI_FUNC(int) _PyLong_UnsignedInt_Converter(PyObject *, void *);
+PyAPI_FUNC(int) _PyLong_UnsignedLong_Converter(PyObject *, void *);
+PyAPI_FUNC(int) _PyLong_UnsignedLongLong_Converter(PyObject *, void *);
+PyAPI_FUNC(int) _PyLong_Size_t_Converter(PyObject *, void *);
+#endif
+
+/* Used by Python/mystrtoul.c, _PyBytes_FromHex(),
+   _PyBytes_DecodeEscape(), etc. */
+#ifndef Py_LIMITED_API
+PyAPI_DATA(unsigned char) _PyLong_DigitValue[256];
+#endif
+
+/* _PyLong_Frexp returns a double x and an exponent e such that the
+   true value is approximately equal to x * 2**e.  e is >= 0.  x is
+   0.0 if and only if the input is 0 (in which case, e and x are both
+   zeroes); otherwise, 0.5 <= abs(x) < 1.0.  On overflow, which is
+   possible if the number of bits doesn't fit into a Py_ssize_t, sets
+   OverflowError and returns -1.0 for x, 0 for e. */
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(double) _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e);
+#endif
+
+PyAPI_FUNC(double) PyLong_AsDouble(PyObject *);
+PyAPI_FUNC(PyObject *) PyLong_FromVoidPtr(void *);
+PyAPI_FUNC(void *) PyLong_AsVoidPtr(PyObject *);
+
+PyAPI_FUNC(PyObject *) PyLong_FromLongLong(long long);
+PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLongLong(unsigned long long);
+PyAPI_FUNC(long long) PyLong_AsLongLong(PyObject *);
+PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLong(PyObject *);
+PyAPI_FUNC(unsigned long long) PyLong_AsUnsignedLongLongMask(PyObject *);
+PyAPI_FUNC(long long) PyLong_AsLongLongAndOverflow(PyObject *, int *);
+
+PyAPI_FUNC(PyObject *) PyLong_FromString(const char *, char **, int);
+#ifndef Py_LIMITED_API
+Py_DEPRECATED(3.3)
+PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int);
+PyAPI_FUNC(PyObject *) PyLong_FromUnicodeObject(PyObject *u, int base);
+PyAPI_FUNC(PyObject *) _PyLong_FromBytes(const char *, Py_ssize_t, int);
+#endif
+
+#ifndef Py_LIMITED_API
+/* _PyLong_Sign.  Return 0 if v is 0, -1 if v < 0, +1 if v > 0.
+   v must not be NULL, and must be a normalized long.
+   There are no error cases.
+*/
+PyAPI_FUNC(int) _PyLong_Sign(PyObject *v);
+
+
+/* _PyLong_NumBits.  Return the number of bits needed to represent the
+   absolute value of a long.  For example, this returns 1 for 1 and -1, 2
+   for 2 and -2, and 2 for 3 and -3.  It returns 0 for 0.
+   v must not be NULL, and must be a normalized long.
+   (size_t)-1 is returned and OverflowError set if the true result doesn't
+   fit in a size_t.
+*/
+PyAPI_FUNC(size_t) _PyLong_NumBits(PyObject *v);
+
+/* _PyLong_DivmodNear.  Given integers a and b, compute the nearest
+   integer q to the exact quotient a / b, rounding to the nearest even integer
+   in the case of a tie.  Return (q, r), where r = a - q*b.  The remainder r
+   will satisfy abs(r) <= abs(b)/2, with equality possible only if q is
+   even.
+*/
+PyAPI_FUNC(PyObject *) _PyLong_DivmodNear(PyObject *, PyObject *);
+
+/* _PyLong_FromByteArray:  View the n unsigned bytes as a binary integer in
+   base 256, and return a Python int with the same numeric value.
+   If n is 0, the integer is 0.  Else:
+   If little_endian is 1/true, bytes[n-1] is the MSB and bytes[0] the LSB;
+   else (little_endian is 0/false) bytes[0] is the MSB and bytes[n-1] the
+   LSB.
+   If is_signed is 0/false, view the bytes as a non-negative integer.
+   If is_signed is 1/true, view the bytes as a 2's-complement integer,
+   non-negative if bit 0x80 of the MSB is clear, negative if set.
+   Error returns:
+   + Return NULL with the appropriate exception set if there's not
+     enough memory to create the Python int.
+*/
+PyAPI_FUNC(PyObject *) _PyLong_FromByteArray(
+    const unsigned char* bytes, size_t n,
+    int little_endian, int is_signed);
+
+/* _PyLong_AsByteArray: Convert the least-significant 8*n bits of long
+   v to a base-256 integer, stored in array bytes.  Normally return 0,
+   return -1 on error.
+   If little_endian is 1/true, store the MSB at bytes[n-1] and the LSB at
+   bytes[0]; else (little_endian is 0/false) store the MSB at bytes[0] and
+   the LSB at bytes[n-1].
+   If is_signed is 0/false, it's an error if v < 0; else (v >= 0) n bytes
+   are filled and there's nothing special about bit 0x80 of the MSB.
+   If is_signed is 1/true, bytes is filled with the 2's-complement
+   representation of v's value.  Bit 0x80 of the MSB is the sign bit.
+   Error returns (-1):
+   + is_signed is 0 and v < 0.  TypeError is set in this case, and bytes
+     isn't altered.
+   + n isn't big enough to hold the full mathematical value of v.  For
+     example, if is_signed is 0 and there are more digits in the v than
+     fit in n; or if is_signed is 1, v < 0, and n is just 1 bit shy of
+     being large enough to hold a sign bit.  OverflowError is set in this
+     case, but bytes holds the least-significant n bytes of the true value.
+*/
+PyAPI_FUNC(int) _PyLong_AsByteArray(PyLongObject* v,
+    unsigned char* bytes, size_t n,
+    int little_endian, int is_signed);
+
+/* _PyLong_FromNbInt: Convert the given object to a PyLongObject
+   using the nb_int slot, if available.  Raise TypeError if either the
+   nb_int slot is not available or the result of the call to nb_int
+   returns something not of type int.
+*/
+PyAPI_FUNC(PyObject *) _PyLong_FromNbInt(PyObject *);
+
+/* Convert the given object to a PyLongObject using the nb_index or
+   nb_int slots, if available (the latter is deprecated).
+   Raise TypeError if either nb_index and nb_int slots are not
+   available or the result of the call to nb_index or nb_int
+   returns something not of type int.
+   Should be replaced with PyNumber_Index after the end of the
+   deprecation period.
+*/
+PyAPI_FUNC(PyObject *) _PyLong_FromNbIndexOrNbInt(PyObject *);
+
+/* _PyLong_Format: Convert the long to a string object with given base,
+   appending a base prefix of 0[box] if base is 2, 8 or 16. */
+PyAPI_FUNC(PyObject *) _PyLong_Format(PyObject *obj, int base);
+
+PyAPI_FUNC(int) _PyLong_FormatWriter(
+    _PyUnicodeWriter *writer,
+    PyObject *obj,
+    int base,
+    int alternate);
+
+PyAPI_FUNC(char*) _PyLong_FormatBytesWriter(
+    _PyBytesWriter *writer,
+    char *str,
+    PyObject *obj,
+    int base,
+    int alternate);
+
+/* Format the object based on the format_spec, as defined in PEP 3101
+   (Advanced String Formatting). */
+PyAPI_FUNC(int) _PyLong_FormatAdvancedWriter(
+    _PyUnicodeWriter *writer,
+    PyObject *obj,
+    PyObject *format_spec,
+    Py_ssize_t start,
+    Py_ssize_t end);
+#endif /* Py_LIMITED_API */
+
+/* These aren't really part of the int object, but they're handy. The
+   functions are in Python/mystrtoul.c.
+ */
+PyAPI_FUNC(unsigned long) PyOS_strtoul(const char *, char **, int);
+PyAPI_FUNC(long) PyOS_strtol(const char *, char **, int);
+
+#ifndef Py_LIMITED_API
+/* For use by the gcd function in mathmodule.c */
+PyAPI_FUNC(PyObject *) _PyLong_GCD(PyObject *, PyObject *);
+#endif /* !Py_LIMITED_API */
+
+#ifndef Py_LIMITED_API
+PyAPI_DATA(PyObject *) _PyLong_Zero;
+PyAPI_DATA(PyObject *) _PyLong_One;
+
+PyAPI_FUNC(PyObject *) _PyLong_Rshift(PyObject *, size_t);
+PyAPI_FUNC(PyObject *) _PyLong_Lshift(PyObject *, size_t);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_LONGOBJECT_H */
diff --git a/marketing/include/marshal.h b/marketing/include/marshal.h
new file mode 100644
index 0000000000000000000000000000000000000000..09d9337e57b0aa3ca18ba4a64bc360f8661ec080
--- /dev/null
+++ b/marketing/include/marshal.h
@@ -0,0 +1,28 @@
+
+/* Interface for marshal.c */
+
+#ifndef Py_MARSHAL_H
+#define Py_MARSHAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define Py_MARSHAL_VERSION 4
+
+PyAPI_FUNC(void) PyMarshal_WriteLongToFile(long, FILE *, int);
+PyAPI_FUNC(void) PyMarshal_WriteObjectToFile(PyObject *, FILE *, int);
+PyAPI_FUNC(PyObject *) PyMarshal_WriteObjectToString(PyObject *, int);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *);
+PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *);
+PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromFile(FILE *);
+PyAPI_FUNC(PyObject *) PyMarshal_ReadLastObjectFromFile(FILE *);
+#endif
+PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(const char *,
+                                                      Py_ssize_t);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_MARSHAL_H */
diff --git a/marketing/include/memoryobject.h b/marketing/include/memoryobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..306028f4b225d8bbd0f0d443969b696cce991fed
--- /dev/null
+++ b/marketing/include/memoryobject.h
@@ -0,0 +1,72 @@
+/* Memory view object. In Python this is available as "memoryview". */
+
+#ifndef Py_MEMORYOBJECT_H
+#define Py_MEMORYOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+PyAPI_DATA(PyTypeObject) _PyManagedBuffer_Type;
+#endif
+PyAPI_DATA(PyTypeObject) PyMemoryView_Type;
+
+#define PyMemoryView_Check(op) Py_IS_TYPE(op, &PyMemoryView_Type)
+
+#ifndef Py_LIMITED_API
+/* Get a pointer to the memoryview's private copy of the exporter's buffer. */
+#define PyMemoryView_GET_BUFFER(op) (&((PyMemoryViewObject *)(op))->view)
+/* Get a pointer to the exporting object (this may be NULL!). */
+#define PyMemoryView_GET_BASE(op) (((PyMemoryViewObject *)(op))->view.obj)
+#endif
+
+PyAPI_FUNC(PyObject *) PyMemoryView_FromObject(PyObject *base);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject *) PyMemoryView_FromMemory(char *mem, Py_ssize_t size,
+                                               int flags);
+#endif
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) PyMemoryView_FromBuffer(Py_buffer *info);
+#endif
+PyAPI_FUNC(PyObject *) PyMemoryView_GetContiguous(PyObject *base,
+                                                  int buffertype,
+                                                  char order);
+
+
+/* The structs are declared here so that macros can work, but they shouldn't
+   be considered public. Don't access their fields directly, use the macros
+   and functions instead! */
+#ifndef Py_LIMITED_API
+#define _Py_MANAGED_BUFFER_RELEASED    0x001  /* access to exporter blocked */
+#define _Py_MANAGED_BUFFER_FREE_FORMAT 0x002  /* free format */
+typedef struct {
+    PyObject_HEAD
+    int flags;          /* state flags */
+    Py_ssize_t exports; /* number of direct memoryview exports */
+    Py_buffer master; /* snapshot buffer obtained from the original exporter */
+} _PyManagedBufferObject;
+
+
+/* memoryview state flags */
+#define _Py_MEMORYVIEW_RELEASED    0x001  /* access to master buffer blocked */
+#define _Py_MEMORYVIEW_C           0x002  /* C-contiguous layout */
+#define _Py_MEMORYVIEW_FORTRAN     0x004  /* Fortran contiguous layout */
+#define _Py_MEMORYVIEW_SCALAR      0x008  /* scalar: ndim = 0 */
+#define _Py_MEMORYVIEW_PIL         0x010  /* PIL-style layout */
+
+typedef struct {
+    PyObject_VAR_HEAD
+    _PyManagedBufferObject *mbuf; /* managed buffer */
+    Py_hash_t hash;               /* hash value for read-only views */
+    int flags;                    /* state flags */
+    Py_ssize_t exports;           /* number of buffer re-exports */
+    Py_buffer view;               /* private copy of the exporter's view */
+    PyObject *weakreflist;
+    Py_ssize_t ob_array[1];       /* shape, strides, suboffsets */
+} PyMemoryViewObject;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_MEMORYOBJECT_H */
diff --git a/marketing/include/methodobject.h b/marketing/include/methodobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..12e049b4043ba59fe15ea709f261cdce10a29a79
--- /dev/null
+++ b/marketing/include/methodobject.h
@@ -0,0 +1,110 @@
+
+/* Method object interface */
+
+#ifndef Py_METHODOBJECT_H
+#define Py_METHODOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is about the type 'builtin_function_or_method',
+   not Python methods in user-defined classes.  See classobject.h
+   for the latter. */
+
+PyAPI_DATA(PyTypeObject) PyCFunction_Type;
+
+#define PyCFunction_CheckExact(op) Py_IS_TYPE(op, &PyCFunction_Type)
+#define PyCFunction_Check(op) PyObject_TypeCheck(op, &PyCFunction_Type)
+
+typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
+typedef PyObject *(*_PyCFunctionFast) (PyObject *, PyObject *const *, Py_ssize_t);
+typedef PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *,
+                                             PyObject *);
+typedef PyObject *(*_PyCFunctionFastWithKeywords) (PyObject *,
+                                                   PyObject *const *, Py_ssize_t,
+                                                   PyObject *);
+typedef PyObject *(*PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *,
+                               size_t, PyObject *);
+
+PyAPI_FUNC(PyCFunction) PyCFunction_GetFunction(PyObject *);
+PyAPI_FUNC(PyObject *) PyCFunction_GetSelf(PyObject *);
+PyAPI_FUNC(int) PyCFunction_GetFlags(PyObject *);
+
+Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyCFunction_Call(PyObject *, PyObject *, PyObject *);
+
+struct PyMethodDef {
+    const char  *ml_name;   /* The name of the built-in function/method */
+    PyCFunction ml_meth;    /* The C function that implements it */
+    int         ml_flags;   /* Combination of METH_xxx flags, which mostly
+                               describe the args expected by the C func */
+    const char  *ml_doc;    /* The __doc__ attribute, or NULL */
+};
+typedef struct PyMethodDef PyMethodDef;
+
+#define PyCFunction_New(ML, SELF) PyCFunction_NewEx((ML), (SELF), NULL)
+PyAPI_FUNC(PyObject *) PyCFunction_NewEx(PyMethodDef *, PyObject *,
+                                         PyObject *);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
+#define PyCFunction_NewEx(ML, SELF, MOD) PyCMethod_New((ML), (SELF), (MOD), NULL)
+PyAPI_FUNC(PyObject *) PyCMethod_New(PyMethodDef *, PyObject *,
+                                     PyObject *, PyTypeObject *);
+#endif
+
+
+/* Flag passed to newmethodobject */
+/* #define METH_OLDARGS  0x0000   -- unsupported now */
+#define METH_VARARGS  0x0001
+#define METH_KEYWORDS 0x0002
+/* METH_NOARGS and METH_O must not be combined with the flags above. */
+#define METH_NOARGS   0x0004
+#define METH_O        0x0008
+
+/* METH_CLASS and METH_STATIC are a little different; these control
+   the construction of methods for a class.  These cannot be used for
+   functions in modules. */
+#define METH_CLASS    0x0010
+#define METH_STATIC   0x0020
+
+/* METH_COEXIST allows a method to be entered even though a slot has
+   already filled the entry.  When defined, the flag allows a separate
+   method, "__contains__" for example, to coexist with a defined
+   slot like sq_contains. */
+
+#define METH_COEXIST   0x0040
+
+#ifndef Py_LIMITED_API
+#define METH_FASTCALL  0x0080
+#endif
+
+/* This bit is preserved for Stackless Python */
+#ifdef STACKLESS
+#define METH_STACKLESS 0x0100
+#else
+#define METH_STACKLESS 0x0000
+#endif
+
+/* METH_METHOD means the function stores an
+ * additional reference to the class that defines it;
+ * both self and class are passed to it.
+ * It uses PyCMethodObject instead of PyCFunctionObject.
+ * May not be combined with METH_NOARGS, METH_O, METH_CLASS or METH_STATIC.
+ */
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
+#define METH_METHOD 0x0200
+#endif
+
+
+#ifndef Py_LIMITED_API
+
+#define Py_CPYTHON_METHODOBJECT_H
+#include  "cpython/methodobject.h"
+#undef Py_CPYTHON_METHODOBJECT_H
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_METHODOBJECT_H */
diff --git a/marketing/include/modsupport.h b/marketing/include/modsupport.h
new file mode 100644
index 0000000000000000000000000000000000000000..4c4aab65bac10376e1f6b3e44df13ff6df8f73a9
--- /dev/null
+++ b/marketing/include/modsupport.h
@@ -0,0 +1,255 @@
+
+#ifndef Py_MODSUPPORT_H
+#define Py_MODSUPPORT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Module support interface */
+
+#include 
+
+/* If PY_SSIZE_T_CLEAN is defined, each functions treats #-specifier
+   to mean Py_ssize_t */
+#ifdef PY_SSIZE_T_CLEAN
+#define PyArg_Parse                     _PyArg_Parse_SizeT
+#define PyArg_ParseTuple                _PyArg_ParseTuple_SizeT
+#define PyArg_ParseTupleAndKeywords     _PyArg_ParseTupleAndKeywords_SizeT
+#define PyArg_VaParse                   _PyArg_VaParse_SizeT
+#define PyArg_VaParseTupleAndKeywords   _PyArg_VaParseTupleAndKeywords_SizeT
+#define Py_BuildValue                   _Py_BuildValue_SizeT
+#define Py_VaBuildValue                 _Py_VaBuildValue_SizeT
+#ifndef Py_LIMITED_API
+#define _Py_VaBuildStack                _Py_VaBuildStack_SizeT
+#endif
+#else
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _Py_VaBuildValue_SizeT(const char *, va_list);
+PyAPI_FUNC(PyObject **) _Py_VaBuildStack_SizeT(
+    PyObject **small_stack,
+    Py_ssize_t small_stack_len,
+    const char *format,
+    va_list va,
+    Py_ssize_t *p_nargs);
+#endif /* !Py_LIMITED_API */
+#endif
+
+/* Due to a glitch in 3.2, the _SizeT versions weren't exported from the DLL. */
+#if !defined(PY_SSIZE_T_CLEAN) || !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(int) PyArg_Parse(PyObject *, const char *, ...);
+PyAPI_FUNC(int) PyArg_ParseTuple(PyObject *, const char *, ...);
+PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
+                                                  const char *, char **, ...);
+PyAPI_FUNC(int) PyArg_VaParse(PyObject *, const char *, va_list);
+PyAPI_FUNC(int) PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
+                                                  const char *, char **, va_list);
+#endif
+PyAPI_FUNC(int) PyArg_ValidateKeywordArguments(PyObject *);
+PyAPI_FUNC(int) PyArg_UnpackTuple(PyObject *, const char *, Py_ssize_t, Py_ssize_t, ...);
+PyAPI_FUNC(PyObject *) Py_BuildValue(const char *, ...);
+PyAPI_FUNC(PyObject *) _Py_BuildValue_SizeT(const char *, ...);
+
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(int) _PyArg_UnpackStack(
+    PyObject *const *args,
+    Py_ssize_t nargs,
+    const char *name,
+    Py_ssize_t min,
+    Py_ssize_t max,
+    ...);
+
+PyAPI_FUNC(int) _PyArg_NoKeywords(const char *funcname, PyObject *kwargs);
+PyAPI_FUNC(int) _PyArg_NoKwnames(const char *funcname, PyObject *kwnames);
+PyAPI_FUNC(int) _PyArg_NoPositional(const char *funcname, PyObject *args);
+#define _PyArg_NoKeywords(funcname, kwargs) \
+    ((kwargs) == NULL || _PyArg_NoKeywords((funcname), (kwargs)))
+#define _PyArg_NoKwnames(funcname, kwnames) \
+    ((kwnames) == NULL || _PyArg_NoKwnames((funcname), (kwnames)))
+#define _PyArg_NoPositional(funcname, args) \
+    ((args) == NULL || _PyArg_NoPositional((funcname), (args)))
+
+PyAPI_FUNC(void) _PyArg_BadArgument(const char *, const char *, const char *, PyObject *);
+PyAPI_FUNC(int) _PyArg_CheckPositional(const char *, Py_ssize_t,
+                                       Py_ssize_t, Py_ssize_t);
+#define _PyArg_CheckPositional(funcname, nargs, min, max) \
+    (((min) <= (nargs) && (nargs) <= (max)) \
+     || _PyArg_CheckPositional((funcname), (nargs), (min), (max)))
+
+#endif
+
+PyAPI_FUNC(PyObject *) Py_VaBuildValue(const char *, va_list);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject **) _Py_VaBuildStack(
+    PyObject **small_stack,
+    Py_ssize_t small_stack_len,
+    const char *format,
+    va_list va,
+    Py_ssize_t *p_nargs);
+#endif
+
+#ifndef Py_LIMITED_API
+typedef struct _PyArg_Parser {
+    const char *format;
+    const char * const *keywords;
+    const char *fname;
+    const char *custom_msg;
+    int pos;            /* number of positional-only arguments */
+    int min;            /* minimal number of arguments */
+    int max;            /* maximal number of positional arguments */
+    PyObject *kwtuple;  /* tuple of keyword parameter names */
+    struct _PyArg_Parser *next;
+} _PyArg_Parser;
+#ifdef PY_SSIZE_T_CLEAN
+#define _PyArg_ParseTupleAndKeywordsFast  _PyArg_ParseTupleAndKeywordsFast_SizeT
+#define _PyArg_ParseStack  _PyArg_ParseStack_SizeT
+#define _PyArg_ParseStackAndKeywords  _PyArg_ParseStackAndKeywords_SizeT
+#define _PyArg_VaParseTupleAndKeywordsFast  _PyArg_VaParseTupleAndKeywordsFast_SizeT
+#endif
+PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywordsFast(PyObject *, PyObject *,
+                                                 struct _PyArg_Parser *, ...);
+PyAPI_FUNC(int) _PyArg_ParseStack(
+    PyObject *const *args,
+    Py_ssize_t nargs,
+    const char *format,
+    ...);
+PyAPI_FUNC(int) _PyArg_ParseStackAndKeywords(
+    PyObject *const *args,
+    Py_ssize_t nargs,
+    PyObject *kwnames,
+    struct _PyArg_Parser *,
+    ...);
+PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywordsFast(PyObject *, PyObject *,
+                                                   struct _PyArg_Parser *, va_list);
+PyAPI_FUNC(PyObject * const *) _PyArg_UnpackKeywords(
+        PyObject *const *args, Py_ssize_t nargs,
+        PyObject *kwargs, PyObject *kwnames,
+        struct _PyArg_Parser *parser,
+        int minpos, int maxpos, int minkw,
+        PyObject **buf);
+#define _PyArg_UnpackKeywords(args, nargs, kwargs, kwnames, parser, minpos, maxpos, minkw, buf) \
+    (((minkw) == 0 && (kwargs) == NULL && (kwnames) == NULL && \
+      (minpos) <= (nargs) && (nargs) <= (maxpos) && args != NULL) ? (args) : \
+     _PyArg_UnpackKeywords((args), (nargs), (kwargs), (kwnames), (parser), \
+                           (minpos), (maxpos), (minkw), (buf)))
+
+void _PyArg_Fini(void);
+#endif   /* Py_LIMITED_API */
+
+PyAPI_FUNC(int) PyModule_AddObject(PyObject *, const char *, PyObject *);
+PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject *, const char *, long);
+PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
+/* New in 3.9 */
+PyAPI_FUNC(int) PyModule_AddType(PyObject *module, PyTypeObject *type);
+#endif /* Py_LIMITED_API */
+#define PyModule_AddIntMacro(m, c) PyModule_AddIntConstant(m, #c, c)
+#define PyModule_AddStringMacro(m, c) PyModule_AddStringConstant(m, #c, c)
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* New in 3.5 */
+PyAPI_FUNC(int) PyModule_SetDocString(PyObject *, const char *);
+PyAPI_FUNC(int) PyModule_AddFunctions(PyObject *, PyMethodDef *);
+PyAPI_FUNC(int) PyModule_ExecDef(PyObject *module, PyModuleDef *def);
+#endif
+
+#define Py_CLEANUP_SUPPORTED 0x20000
+
+#define PYTHON_API_VERSION 1013
+#define PYTHON_API_STRING "1013"
+/* The API version is maintained (independently from the Python version)
+   so we can detect mismatches between the interpreter and dynamically
+   loaded modules.  These are diagnosed by an error message but
+   the module is still loaded (because the mismatch can only be tested
+   after loading the module).  The error message is intended to
+   explain the core dump a few seconds later.
+
+   The symbol PYTHON_API_STRING defines the same value as a string
+   literal.  *** PLEASE MAKE SURE THE DEFINITIONS MATCH. ***
+
+   Please add a line or two to the top of this log for each API
+   version change:
+
+   22-Feb-2006  MvL     1013    PEP 353 - long indices for sequence lengths
+
+   19-Aug-2002  GvR     1012    Changes to string object struct for
+                                interning changes, saving 3 bytes.
+
+   17-Jul-2001  GvR     1011    Descr-branch, just to be on the safe side
+
+   25-Jan-2001  FLD     1010    Parameters added to PyCode_New() and
+                                PyFrame_New(); Python 2.1a2
+
+   14-Mar-2000  GvR     1009    Unicode API added
+
+   3-Jan-1999   GvR     1007    Decided to change back!  (Don't reuse 1008!)
+
+   3-Dec-1998   GvR     1008    Python 1.5.2b1
+
+   18-Jan-1997  GvR     1007    string interning and other speedups
+
+   11-Oct-1996  GvR     renamed Py_Ellipses to Py_Ellipsis :-(
+
+   30-Jul-1996  GvR     Slice and ellipses syntax added
+
+   23-Jul-1996  GvR     For 1.4 -- better safe than sorry this time :-)
+
+   7-Nov-1995   GvR     Keyword arguments (should've been done at 1.3 :-( )
+
+   10-Jan-1995  GvR     Renamed globals to new naming scheme
+
+   9-Jan-1995   GvR     Initial version (incompatible with older API)
+*/
+
+/* The PYTHON_ABI_VERSION is introduced in PEP 384. For the lifetime of
+   Python 3, it will stay at the value of 3; changes to the limited API
+   must be performed in a strictly backwards-compatible manner. */
+#define PYTHON_ABI_VERSION 3
+#define PYTHON_ABI_STRING "3"
+
+#ifdef Py_TRACE_REFS
+ /* When we are tracing reference counts, rename module creation functions so
+    modules compiled with incompatible settings will generate a
+    link-time error. */
+ #define PyModule_Create2 PyModule_Create2TraceRefs
+ #define PyModule_FromDefAndSpec2 PyModule_FromDefAndSpec2TraceRefs
+#endif
+
+PyAPI_FUNC(PyObject *) PyModule_Create2(struct PyModuleDef*,
+                                     int apiver);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _PyModule_CreateInitialized(struct PyModuleDef*,
+                                                   int apiver);
+#endif
+
+#ifdef Py_LIMITED_API
+#define PyModule_Create(module) \
+        PyModule_Create2(module, PYTHON_ABI_VERSION)
+#else
+#define PyModule_Create(module) \
+        PyModule_Create2(module, PYTHON_API_VERSION)
+#endif
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* New in 3.5 */
+PyAPI_FUNC(PyObject *) PyModule_FromDefAndSpec2(PyModuleDef *def,
+                                                PyObject *spec,
+                                                int module_api_version);
+
+#ifdef Py_LIMITED_API
+#define PyModule_FromDefAndSpec(module, spec) \
+    PyModule_FromDefAndSpec2(module, spec, PYTHON_ABI_VERSION)
+#else
+#define PyModule_FromDefAndSpec(module, spec) \
+    PyModule_FromDefAndSpec2(module, spec, PYTHON_API_VERSION)
+#endif /* Py_LIMITED_API */
+#endif /* New in 3.5 */
+
+#ifndef Py_LIMITED_API
+PyAPI_DATA(const char *) _Py_PackageContext;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_MODSUPPORT_H */
diff --git a/marketing/include/moduleobject.h b/marketing/include/moduleobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf9ad40c0a17a0518f169d9d0d18645206da0cbb
--- /dev/null
+++ b/marketing/include/moduleobject.h
@@ -0,0 +1,90 @@
+
+/* Module object interface */
+
+#ifndef Py_MODULEOBJECT_H
+#define Py_MODULEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyModule_Type;
+
+#define PyModule_Check(op) PyObject_TypeCheck(op, &PyModule_Type)
+#define PyModule_CheckExact(op) Py_IS_TYPE(op, &PyModule_Type)
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject *) PyModule_NewObject(
+    PyObject *name
+    );
+#endif
+PyAPI_FUNC(PyObject *) PyModule_New(
+    const char *name            /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(PyObject *) PyModule_GetDict(PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject *) PyModule_GetNameObject(PyObject *);
+#endif
+PyAPI_FUNC(const char *) PyModule_GetName(PyObject *);
+Py_DEPRECATED(3.2) PyAPI_FUNC(const char *) PyModule_GetFilename(PyObject *);
+PyAPI_FUNC(PyObject *) PyModule_GetFilenameObject(PyObject *);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(void) _PyModule_Clear(PyObject *);
+PyAPI_FUNC(void) _PyModule_ClearDict(PyObject *);
+PyAPI_FUNC(int) _PyModuleSpec_IsInitializing(PyObject *);
+#endif
+PyAPI_FUNC(struct PyModuleDef*) PyModule_GetDef(PyObject*);
+PyAPI_FUNC(void*) PyModule_GetState(PyObject*);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* New in 3.5 */
+PyAPI_FUNC(PyObject *) PyModuleDef_Init(struct PyModuleDef*);
+PyAPI_DATA(PyTypeObject) PyModuleDef_Type;
+#endif
+
+typedef struct PyModuleDef_Base {
+  PyObject_HEAD
+  PyObject* (*m_init)(void);
+  Py_ssize_t m_index;
+  PyObject* m_copy;
+} PyModuleDef_Base;
+
+#define PyModuleDef_HEAD_INIT { \
+    PyObject_HEAD_INIT(NULL)    \
+    NULL, /* m_init */          \
+    0,    /* m_index */         \
+    NULL, /* m_copy */          \
+  }
+
+struct PyModuleDef_Slot;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* New in 3.5 */
+typedef struct PyModuleDef_Slot{
+    int slot;
+    void *value;
+} PyModuleDef_Slot;
+
+#define Py_mod_create 1
+#define Py_mod_exec 2
+
+#ifndef Py_LIMITED_API
+#define _Py_mod_LAST_SLOT 2
+#endif
+
+#endif /* New in 3.5 */
+
+typedef struct PyModuleDef{
+  PyModuleDef_Base m_base;
+  const char* m_name;
+  const char* m_doc;
+  Py_ssize_t m_size;
+  PyMethodDef *m_methods;
+  struct PyModuleDef_Slot* m_slots;
+  traverseproc m_traverse;
+  inquiry m_clear;
+  freefunc m_free;
+} PyModuleDef;
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_MODULEOBJECT_H */
diff --git a/marketing/include/namespaceobject.h b/marketing/include/namespaceobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..0c8d95c0f137c689c1e6cf7ffa6d5b91cc255641
--- /dev/null
+++ b/marketing/include/namespaceobject.h
@@ -0,0 +1,19 @@
+
+/* simple namespace object interface */
+
+#ifndef NAMESPACEOBJECT_H
+#define NAMESPACEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+PyAPI_DATA(PyTypeObject) _PyNamespace_Type;
+
+PyAPI_FUNC(PyObject *) _PyNamespace_New(PyObject *kwds);
+#endif /* !Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !NAMESPACEOBJECT_H */
diff --git a/marketing/include/node.h b/marketing/include/node.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca24f289085920e5c87cbb27beed4cf4d7e19b22
--- /dev/null
+++ b/marketing/include/node.h
@@ -0,0 +1,47 @@
+
+/* Parse tree node interface */
+
+#ifndef Py_NODE_H
+#define Py_NODE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _node {
+    short               n_type;
+    char                *n_str;
+    int                 n_lineno;
+    int                 n_col_offset;
+    int                 n_nchildren;
+    struct _node        *n_child;
+    int                 n_end_lineno;
+    int                 n_end_col_offset;
+} node;
+
+PyAPI_FUNC(node *) PyNode_New(int type);
+PyAPI_FUNC(int) PyNode_AddChild(node *n, int type,
+                                char *str, int lineno, int col_offset,
+                                int end_lineno, int end_col_offset);
+PyAPI_FUNC(void) PyNode_Free(node *n);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(Py_ssize_t) _PyNode_SizeOf(node *n);
+#endif
+
+/* Node access functions */
+#define NCH(n)          ((n)->n_nchildren)
+
+#define CHILD(n, i)     (&(n)->n_child[i])
+#define TYPE(n)         ((n)->n_type)
+#define STR(n)          ((n)->n_str)
+#define LINENO(n)       ((n)->n_lineno)
+
+/* Assert that the type of a node is what we expect */
+#define REQ(n, type) assert(TYPE(n) == (type))
+
+PyAPI_FUNC(void) PyNode_ListTree(node *);
+void _PyNode_FinalizeEndPos(node *n);  // helper also used in parsetok.c
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_NODE_H */
diff --git a/marketing/include/object.h b/marketing/include/object.h
new file mode 100644
index 0000000000000000000000000000000000000000..9c1a7f479e44906a2cf5a9f69e12dbfc7e7cf557
--- /dev/null
+++ b/marketing/include/object.h
@@ -0,0 +1,648 @@
+#ifndef Py_OBJECT_H
+#define Py_OBJECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Object and type object interface */
+
+/*
+Objects are structures allocated on the heap.  Special rules apply to
+the use of objects to ensure they are properly garbage-collected.
+Objects are never allocated statically or on the stack; they must be
+accessed through special macros and functions only.  (Type objects are
+exceptions to the first rule; the standard types are represented by
+statically initialized type objects, although work on type/class unification
+for Python 2.2 made it possible to have heap-allocated type objects too).
+
+An object has a 'reference count' that is increased or decreased when a
+pointer to the object is copied or deleted; when the reference count
+reaches zero there are no references to the object left and it can be
+removed from the heap.
+
+An object has a 'type' that determines what it represents and what kind
+of data it contains.  An object's type is fixed when it is created.
+Types themselves are represented as objects; an object contains a
+pointer to the corresponding type object.  The type itself has a type
+pointer pointing to the object representing the type 'type', which
+contains a pointer to itself!.
+
+Objects do not float around in memory; once allocated an object keeps
+the same size and address.  Objects that must hold variable-size data
+can contain pointers to variable-size parts of the object.  Not all
+objects of the same type have the same size; but the size cannot change
+after allocation.  (These restrictions are made so a reference to an
+object can be simply a pointer -- moving an object would require
+updating all the pointers, and changing an object's size would require
+moving it if there was another object right next to it.)
+
+Objects are always accessed through pointers of the type 'PyObject *'.
+The type 'PyObject' is a structure that only contains the reference count
+and the type pointer.  The actual memory allocated for an object
+contains other data that can only be accessed after casting the pointer
+to a pointer to a longer structure type.  This longer type must start
+with the reference count and type fields; the macro PyObject_HEAD should be
+used for this (to accommodate for future changes).  The implementation
+of a particular object type can cast the object pointer to the proper
+type and back.
+
+A standard interface exists for objects that contain an array of items
+whose size is determined when the object is allocated.
+*/
+
+/* Py_DEBUG implies Py_REF_DEBUG. */
+#if defined(Py_DEBUG) && !defined(Py_REF_DEBUG)
+#define Py_REF_DEBUG
+#endif
+
+#if defined(Py_LIMITED_API) && defined(Py_REF_DEBUG)
+#error Py_LIMITED_API is incompatible with Py_DEBUG, Py_TRACE_REFS, and Py_REF_DEBUG
+#endif
+
+/* PyTypeObject structure is defined in cpython/object.h.
+   In Py_LIMITED_API, PyTypeObject is an opaque structure. */
+typedef struct _typeobject PyTypeObject;
+
+#ifdef Py_TRACE_REFS
+/* Define pointers to support a doubly-linked list of all live heap objects. */
+#define _PyObject_HEAD_EXTRA            \
+    struct _object *_ob_next;           \
+    struct _object *_ob_prev;
+
+#define _PyObject_EXTRA_INIT 0, 0,
+
+#else
+#define _PyObject_HEAD_EXTRA
+#define _PyObject_EXTRA_INIT
+#endif
+
+/* PyObject_HEAD defines the initial segment of every PyObject. */
+#define PyObject_HEAD                   PyObject ob_base;
+
+#define PyObject_HEAD_INIT(type)        \
+    { _PyObject_EXTRA_INIT              \
+    1, type },
+
+#define PyVarObject_HEAD_INIT(type, size)       \
+    { PyObject_HEAD_INIT(type) size },
+
+/* PyObject_VAR_HEAD defines the initial segment of all variable-size
+ * container objects.  These end with a declaration of an array with 1
+ * element, but enough space is malloc'ed so that the array actually
+ * has room for ob_size elements.  Note that ob_size is an element count,
+ * not necessarily a byte count.
+ */
+#define PyObject_VAR_HEAD      PyVarObject ob_base;
+#define Py_INVALID_SIZE (Py_ssize_t)-1
+
+/* Nothing is actually declared to be a PyObject, but every pointer to
+ * a Python object can be cast to a PyObject*.  This is inheritance built
+ * by hand.  Similarly every pointer to a variable-size Python object can,
+ * in addition, be cast to PyVarObject*.
+ */
+typedef struct _object {
+    _PyObject_HEAD_EXTRA
+    Py_ssize_t ob_refcnt;
+    PyTypeObject *ob_type;
+} PyObject;
+
+/* Cast argument to PyObject* type. */
+#define _PyObject_CAST(op) ((PyObject*)(op))
+#define _PyObject_CAST_CONST(op) ((const PyObject*)(op))
+
+typedef struct {
+    PyObject ob_base;
+    Py_ssize_t ob_size; /* Number of items in variable part */
+} PyVarObject;
+
+/* Cast argument to PyVarObject* type. */
+#define _PyVarObject_CAST(op) ((PyVarObject*)(op))
+
+#define Py_REFCNT(ob)           (_PyObject_CAST(ob)->ob_refcnt)
+#define Py_TYPE(ob)             (_PyObject_CAST(ob)->ob_type)
+#define Py_SIZE(ob)             (_PyVarObject_CAST(ob)->ob_size)
+
+static inline int _Py_IS_TYPE(const PyObject *ob, const PyTypeObject *type) {
+    return ob->ob_type == type;
+}
+#define Py_IS_TYPE(ob, type) _Py_IS_TYPE(_PyObject_CAST_CONST(ob), type)
+
+static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) {
+    ob->ob_refcnt = refcnt;
+}
+#define Py_SET_REFCNT(ob, refcnt) _Py_SET_REFCNT(_PyObject_CAST(ob), refcnt)
+
+static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) {
+    ob->ob_type = type;
+}
+#define Py_SET_TYPE(ob, type) _Py_SET_TYPE(_PyObject_CAST(ob), type)
+
+static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size) {
+    ob->ob_size = size;
+}
+#define Py_SET_SIZE(ob, size) _Py_SET_SIZE(_PyVarObject_CAST(ob), size)
+
+
+/*
+Type objects contain a string containing the type name (to help somewhat
+in debugging), the allocation parameters (see PyObject_New() and
+PyObject_NewVar()),
+and methods for accessing objects of the type.  Methods are optional, a
+nil pointer meaning that particular kind of access is not available for
+this type.  The Py_DECREF() macro uses the tp_dealloc method without
+checking for a nil pointer; it should always be implemented except if
+the implementation can guarantee that the reference count will never
+reach zero (e.g., for statically allocated type objects).
+
+NB: the methods for certain type groups are now contained in separate
+method blocks.
+*/
+
+typedef PyObject * (*unaryfunc)(PyObject *);
+typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
+typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
+typedef int (*inquiry)(PyObject *);
+typedef Py_ssize_t (*lenfunc)(PyObject *);
+typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
+typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
+typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
+typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
+typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
+
+typedef int (*objobjproc)(PyObject *, PyObject *);
+typedef int (*visitproc)(PyObject *, void *);
+typedef int (*traverseproc)(PyObject *, visitproc, void *);
+
+
+typedef void (*freefunc)(void *);
+typedef void (*destructor)(PyObject *);
+typedef PyObject *(*getattrfunc)(PyObject *, char *);
+typedef PyObject *(*getattrofunc)(PyObject *, PyObject *);
+typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
+typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
+typedef PyObject *(*reprfunc)(PyObject *);
+typedef Py_hash_t (*hashfunc)(PyObject *);
+typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
+typedef PyObject *(*getiterfunc) (PyObject *);
+typedef PyObject *(*iternextfunc) (PyObject *);
+typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
+typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
+typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
+typedef PyObject *(*newfunc)(PyTypeObject *, PyObject *, PyObject *);
+typedef PyObject *(*allocfunc)(PyTypeObject *, Py_ssize_t);
+
+typedef struct{
+    int slot;    /* slot id, see below */
+    void *pfunc; /* function pointer */
+} PyType_Slot;
+
+typedef struct{
+    const char* name;
+    int basicsize;
+    int itemsize;
+    unsigned int flags;
+    PyType_Slot *slots; /* terminated by slot==0. */
+} PyType_Spec;
+
+PyAPI_FUNC(PyObject*) PyType_FromSpec(PyType_Spec*);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject*) PyType_FromSpecWithBases(PyType_Spec*, PyObject*);
+#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
+PyAPI_FUNC(void*) PyType_GetSlot(PyTypeObject*, int);
+#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
+PyAPI_FUNC(PyObject*) PyType_FromModuleAndSpec(PyObject *, PyType_Spec *, PyObject *);
+PyAPI_FUNC(PyObject *) PyType_GetModule(struct _typeobject *);
+PyAPI_FUNC(void *) PyType_GetModuleState(struct _typeobject *);
+#endif
+
+/* Generic type check */
+PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject *, PyTypeObject *);
+#define PyObject_TypeCheck(ob, tp) \
+    (Py_IS_TYPE(ob, tp) || PyType_IsSubtype(Py_TYPE(ob), (tp)))
+
+PyAPI_DATA(PyTypeObject) PyType_Type; /* built-in 'type' */
+PyAPI_DATA(PyTypeObject) PyBaseObject_Type; /* built-in 'object' */
+PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */
+
+PyAPI_FUNC(unsigned long) PyType_GetFlags(PyTypeObject*);
+
+PyAPI_FUNC(int) PyType_Ready(PyTypeObject *);
+PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
+PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *,
+                                               PyObject *, PyObject *);
+PyAPI_FUNC(unsigned int) PyType_ClearCache(void);
+PyAPI_FUNC(void) PyType_Modified(PyTypeObject *);
+
+/* Generic operations on objects */
+PyAPI_FUNC(PyObject *) PyObject_Repr(PyObject *);
+PyAPI_FUNC(PyObject *) PyObject_Str(PyObject *);
+PyAPI_FUNC(PyObject *) PyObject_ASCII(PyObject *);
+PyAPI_FUNC(PyObject *) PyObject_Bytes(PyObject *);
+PyAPI_FUNC(PyObject *) PyObject_RichCompare(PyObject *, PyObject *, int);
+PyAPI_FUNC(int) PyObject_RichCompareBool(PyObject *, PyObject *, int);
+PyAPI_FUNC(PyObject *) PyObject_GetAttrString(PyObject *, const char *);
+PyAPI_FUNC(int) PyObject_SetAttrString(PyObject *, const char *, PyObject *);
+PyAPI_FUNC(int) PyObject_HasAttrString(PyObject *, const char *);
+PyAPI_FUNC(PyObject *) PyObject_GetAttr(PyObject *, PyObject *);
+PyAPI_FUNC(int) PyObject_SetAttr(PyObject *, PyObject *, PyObject *);
+PyAPI_FUNC(int) PyObject_HasAttr(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyObject_SelfIter(PyObject *);
+PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *);
+PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *, PyObject *, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(int) PyObject_GenericSetDict(PyObject *, PyObject *, void *);
+#endif
+PyAPI_FUNC(Py_hash_t) PyObject_Hash(PyObject *);
+PyAPI_FUNC(Py_hash_t) PyObject_HashNotImplemented(PyObject *);
+PyAPI_FUNC(int) PyObject_IsTrue(PyObject *);
+PyAPI_FUNC(int) PyObject_Not(PyObject *);
+PyAPI_FUNC(int) PyCallable_Check(PyObject *);
+PyAPI_FUNC(void) PyObject_ClearWeakRefs(PyObject *);
+
+/* PyObject_Dir(obj) acts like Python builtins.dir(obj), returning a
+   list of strings.  PyObject_Dir(NULL) is like builtins.dir(),
+   returning the names of the current locals.  In this case, if there are
+   no current locals, NULL is returned, and PyErr_Occurred() is false.
+*/
+PyAPI_FUNC(PyObject *) PyObject_Dir(PyObject *);
+
+
+/* Helpers for printing recursive container types */
+PyAPI_FUNC(int) Py_ReprEnter(PyObject *);
+PyAPI_FUNC(void) Py_ReprLeave(PyObject *);
+
+/* Flag bits for printing: */
+#define Py_PRINT_RAW    1       /* No string quotes etc. */
+
+/*
+Type flags (tp_flags)
+
+These flags are used to change expected features and behavior for a
+particular type.
+
+Arbitration of the flag bit positions will need to be coordinated among
+all extension writers who publicly release their extensions (this will
+be fewer than you might expect!).
+
+Most flags were removed as of Python 3.0 to make room for new flags.  (Some
+flags are not for backwards compatibility but to indicate the presence of an
+optional feature; these flags remain of course.)
+
+Type definitions should use Py_TPFLAGS_DEFAULT for their tp_flags value.
+
+Code can use PyType_HasFeature(type_ob, flag_value) to test whether the
+given type object has a specified feature.
+*/
+
+/* Set if the type object is dynamically allocated */
+#define Py_TPFLAGS_HEAPTYPE (1UL << 9)
+
+/* Set if the type allows subclassing */
+#define Py_TPFLAGS_BASETYPE (1UL << 10)
+
+/* Set if the type implements the vectorcall protocol (PEP 590) */
+#ifndef Py_LIMITED_API
+#define Py_TPFLAGS_HAVE_VECTORCALL (1UL << 11)
+// Backwards compatibility alias for API that was provisional in Python 3.8
+#define _Py_TPFLAGS_HAVE_VECTORCALL Py_TPFLAGS_HAVE_VECTORCALL
+#endif
+
+/* Set if the type is 'ready' -- fully initialized */
+#define Py_TPFLAGS_READY (1UL << 12)
+
+/* Set while the type is being 'readied', to prevent recursive ready calls */
+#define Py_TPFLAGS_READYING (1UL << 13)
+
+/* Objects support garbage collection (see objimpl.h) */
+#define Py_TPFLAGS_HAVE_GC (1UL << 14)
+
+/* These two bits are preserved for Stackless Python, next after this is 17 */
+#ifdef STACKLESS
+#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3UL << 15)
+#else
+#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0
+#endif
+
+/* Objects behave like an unbound method */
+#define Py_TPFLAGS_METHOD_DESCRIPTOR (1UL << 17)
+
+/* Objects support type attribute cache */
+#define Py_TPFLAGS_HAVE_VERSION_TAG   (1UL << 18)
+#define Py_TPFLAGS_VALID_VERSION_TAG  (1UL << 19)
+
+/* Type is abstract and cannot be instantiated */
+#define Py_TPFLAGS_IS_ABSTRACT (1UL << 20)
+
+/* These flags are used to determine if a type is a subclass. */
+#define Py_TPFLAGS_LONG_SUBCLASS        (1UL << 24)
+#define Py_TPFLAGS_LIST_SUBCLASS        (1UL << 25)
+#define Py_TPFLAGS_TUPLE_SUBCLASS       (1UL << 26)
+#define Py_TPFLAGS_BYTES_SUBCLASS       (1UL << 27)
+#define Py_TPFLAGS_UNICODE_SUBCLASS     (1UL << 28)
+#define Py_TPFLAGS_DICT_SUBCLASS        (1UL << 29)
+#define Py_TPFLAGS_BASE_EXC_SUBCLASS    (1UL << 30)
+#define Py_TPFLAGS_TYPE_SUBCLASS        (1UL << 31)
+
+#define Py_TPFLAGS_DEFAULT  ( \
+                 Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \
+                 Py_TPFLAGS_HAVE_VERSION_TAG | \
+                0)
+
+/* NOTE: The following flags reuse lower bits (removed as part of the
+ * Python 3.0 transition). */
+
+/* The following flag is kept for compatibility. Starting with 3.8,
+ * binary compatibility of C extensions across feature releases of
+ * Python is not supported anymore, except when using the stable ABI.
+ */
+
+/* Type structure has tp_finalize member (3.4) */
+#define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0)
+
+
+/*
+The macros Py_INCREF(op) and Py_DECREF(op) are used to increment or decrement
+reference counts.  Py_DECREF calls the object's deallocator function when
+the refcount falls to 0; for
+objects that don't contain references to other objects or heap memory
+this can be the standard function free().  Both macros can be used
+wherever a void expression is allowed.  The argument must not be a
+NULL pointer.  If it may be NULL, use Py_XINCREF/Py_XDECREF instead.
+The macro _Py_NewReference(op) initialize reference counts to 1, and
+in special builds (Py_REF_DEBUG, Py_TRACE_REFS) performs additional
+bookkeeping appropriate to the special build.
+
+We assume that the reference count field can never overflow; this can
+be proven when the size of the field is the same as the pointer size, so
+we ignore the possibility.  Provided a C int is at least 32 bits (which
+is implicitly assumed in many parts of this code), that's enough for
+about 2**31 references to an object.
+
+XXX The following became out of date in Python 2.2, but I'm not sure
+XXX what the full truth is now.  Certainly, heap-allocated type objects
+XXX can and should be deallocated.
+Type objects should never be deallocated; the type pointer in an object
+is not considered to be a reference to the type object, to save
+complications in the deallocation function.  (This is actually a
+decision that's up to the implementer of each new type so if you want,
+you can count such references to the type object.)
+*/
+
+#ifdef Py_REF_DEBUG
+PyAPI_DATA(Py_ssize_t) _Py_RefTotal;
+PyAPI_FUNC(void) _Py_NegativeRefcount(const char *filename, int lineno,
+                                      PyObject *op);
+#endif /* Py_REF_DEBUG */
+
+PyAPI_FUNC(void) _Py_Dealloc(PyObject *);
+
+static inline void _Py_INCREF(PyObject *op)
+{
+#ifdef Py_REF_DEBUG
+    _Py_RefTotal++;
+#endif
+    op->ob_refcnt++;
+}
+
+#define Py_INCREF(op) _Py_INCREF(_PyObject_CAST(op))
+
+static inline void _Py_DECREF(
+#ifdef Py_REF_DEBUG
+    const char *filename, int lineno,
+#endif
+    PyObject *op)
+{
+#ifdef Py_REF_DEBUG
+    _Py_RefTotal--;
+#endif
+    if (--op->ob_refcnt != 0) {
+#ifdef Py_REF_DEBUG
+        if (op->ob_refcnt < 0) {
+            _Py_NegativeRefcount(filename, lineno, op);
+        }
+#endif
+    }
+    else {
+        _Py_Dealloc(op);
+    }
+}
+
+#ifdef Py_REF_DEBUG
+#  define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))
+#else
+#  define Py_DECREF(op) _Py_DECREF(_PyObject_CAST(op))
+#endif
+
+
+/* Safely decref `op` and set `op` to NULL, especially useful in tp_clear
+ * and tp_dealloc implementations.
+ *
+ * Note that "the obvious" code can be deadly:
+ *
+ *     Py_XDECREF(op);
+ *     op = NULL;
+ *
+ * Typically, `op` is something like self->containee, and `self` is done
+ * using its `containee` member.  In the code sequence above, suppose
+ * `containee` is non-NULL with a refcount of 1.  Its refcount falls to
+ * 0 on the first line, which can trigger an arbitrary amount of code,
+ * possibly including finalizers (like __del__ methods or weakref callbacks)
+ * coded in Python, which in turn can release the GIL and allow other threads
+ * to run, etc.  Such code may even invoke methods of `self` again, or cause
+ * cyclic gc to trigger, but-- oops! --self->containee still points to the
+ * object being torn down, and it may be in an insane state while being torn
+ * down.  This has in fact been a rich historic source of miserable (rare &
+ * hard-to-diagnose) segfaulting (and other) bugs.
+ *
+ * The safe way is:
+ *
+ *      Py_CLEAR(op);
+ *
+ * That arranges to set `op` to NULL _before_ decref'ing, so that any code
+ * triggered as a side-effect of `op` getting torn down no longer believes
+ * `op` points to a valid object.
+ *
+ * There are cases where it's safe to use the naive code, but they're brittle.
+ * For example, if `op` points to a Python integer, you know that destroying
+ * one of those can't cause problems -- but in part that relies on that
+ * Python integers aren't currently weakly referencable.  Best practice is
+ * to use Py_CLEAR() even if you can't think of a reason for why you need to.
+ */
+#define Py_CLEAR(op)                            \
+    do {                                        \
+        PyObject *_py_tmp = _PyObject_CAST(op); \
+        if (_py_tmp != NULL) {                  \
+            (op) = NULL;                        \
+            Py_DECREF(_py_tmp);                 \
+        }                                       \
+    } while (0)
+
+/* Function to use in case the object pointer can be NULL: */
+static inline void _Py_XINCREF(PyObject *op)
+{
+    if (op != NULL) {
+        Py_INCREF(op);
+    }
+}
+
+#define Py_XINCREF(op) _Py_XINCREF(_PyObject_CAST(op))
+
+static inline void _Py_XDECREF(PyObject *op)
+{
+    if (op != NULL) {
+        Py_DECREF(op);
+    }
+}
+
+#define Py_XDECREF(op) _Py_XDECREF(_PyObject_CAST(op))
+
+/*
+These are provided as conveniences to Python runtime embedders, so that
+they can have object code that is not dependent on Python compilation flags.
+*/
+PyAPI_FUNC(void) Py_IncRef(PyObject *);
+PyAPI_FUNC(void) Py_DecRef(PyObject *);
+
+/*
+_Py_NoneStruct is an object of undefined type which can be used in contexts
+where NULL (nil) is not suitable (since NULL often means 'error').
+
+Don't forget to apply Py_INCREF() when returning this value!!!
+*/
+PyAPI_DATA(PyObject) _Py_NoneStruct; /* Don't use this directly */
+#define Py_None (&_Py_NoneStruct)
+
+/* Macro for returning Py_None from a function */
+#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
+
+/*
+Py_NotImplemented is a singleton used to signal that an operation is
+not implemented for a given type combination.
+*/
+PyAPI_DATA(PyObject) _Py_NotImplementedStruct; /* Don't use this directly */
+#define Py_NotImplemented (&_Py_NotImplementedStruct)
+
+/* Macro for returning Py_NotImplemented from a function */
+#define Py_RETURN_NOTIMPLEMENTED \
+    return Py_INCREF(Py_NotImplemented), Py_NotImplemented
+
+/* Rich comparison opcodes */
+#define Py_LT 0
+#define Py_LE 1
+#define Py_EQ 2
+#define Py_NE 3
+#define Py_GT 4
+#define Py_GE 5
+
+/*
+ * Macro for implementing rich comparisons
+ *
+ * Needs to be a macro because any C-comparable type can be used.
+ */
+#define Py_RETURN_RICHCOMPARE(val1, val2, op)                               \
+    do {                                                                    \
+        switch (op) {                                                       \
+        case Py_EQ: if ((val1) == (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE;  \
+        case Py_NE: if ((val1) != (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE;  \
+        case Py_LT: if ((val1) < (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE;   \
+        case Py_GT: if ((val1) > (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE;   \
+        case Py_LE: if ((val1) <= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE;  \
+        case Py_GE: if ((val1) >= (val2)) Py_RETURN_TRUE; Py_RETURN_FALSE;  \
+        default:                                                            \
+            Py_UNREACHABLE();                                               \
+        }                                                                   \
+    } while (0)
+
+
+/*
+More conventions
+================
+
+Argument Checking
+-----------------
+
+Functions that take objects as arguments normally don't check for nil
+arguments, but they do check the type of the argument, and return an
+error if the function doesn't apply to the type.
+
+Failure Modes
+-------------
+
+Functions may fail for a variety of reasons, including running out of
+memory.  This is communicated to the caller in two ways: an error string
+is set (see errors.h), and the function result differs: functions that
+normally return a pointer return NULL for failure, functions returning
+an integer return -1 (which could be a legal return value too!), and
+other functions return 0 for success and -1 for failure.
+Callers should always check for errors before using the result.  If
+an error was set, the caller must either explicitly clear it, or pass
+the error on to its caller.
+
+Reference Counts
+----------------
+
+It takes a while to get used to the proper usage of reference counts.
+
+Functions that create an object set the reference count to 1; such new
+objects must be stored somewhere or destroyed again with Py_DECREF().
+Some functions that 'store' objects, such as PyTuple_SetItem() and
+PyList_SetItem(),
+don't increment the reference count of the object, since the most
+frequent use is to store a fresh object.  Functions that 'retrieve'
+objects, such as PyTuple_GetItem() and PyDict_GetItemString(), also
+don't increment
+the reference count, since most frequently the object is only looked at
+quickly.  Thus, to retrieve an object and store it again, the caller
+must call Py_INCREF() explicitly.
+
+NOTE: functions that 'consume' a reference count, like
+PyList_SetItem(), consume the reference even if the object wasn't
+successfully stored, to simplify error handling.
+
+It seems attractive to make other functions that take an object as
+argument consume a reference count; however, this may quickly get
+confusing (even the current practice is already confusing).  Consider
+it carefully, it may save lots of calls to Py_INCREF() and Py_DECREF() at
+times.
+*/
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_OBJECT_H
+#  include  "cpython/object.h"
+#  undef Py_CPYTHON_OBJECT_H
+#endif
+
+
+static inline int
+PyType_HasFeature(PyTypeObject *type, unsigned long feature)
+{
+    unsigned long flags;
+#ifdef Py_LIMITED_API
+    // PyTypeObject is opaque in the limited C API
+    flags = PyType_GetFlags(type);
+#else
+    flags = type->tp_flags;
+#endif
+    return ((flags & feature) != 0);
+}
+
+#define PyType_FastSubclass(type, flag) PyType_HasFeature(type, flag)
+
+static inline int _PyType_Check(PyObject *op) {
+    return PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS);
+}
+#define PyType_Check(op) _PyType_Check(_PyObject_CAST(op))
+
+static inline int _PyType_CheckExact(PyObject *op) {
+    return Py_IS_TYPE(op, &PyType_Type);
+}
+#define PyType_CheckExact(op) _PyType_CheckExact(_PyObject_CAST(op))
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_OBJECT_H */
diff --git a/marketing/include/objimpl.h b/marketing/include/objimpl.h
new file mode 100644
index 0000000000000000000000000000000000000000..030d7eee29723e3e71b869edf36d15b612462bd6
--- /dev/null
+++ b/marketing/include/objimpl.h
@@ -0,0 +1,215 @@
+/* The PyObject_ memory family:  high-level object memory interfaces.
+   See pymem.h for the low-level PyMem_ family.
+*/
+
+#ifndef Py_OBJIMPL_H
+#define Py_OBJIMPL_H
+
+#include "pymem.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BEWARE:
+
+   Each interface exports both functions and macros.  Extension modules should
+   use the functions, to ensure binary compatibility across Python versions.
+   Because the Python implementation is free to change internal details, and
+   the macros may (or may not) expose details for speed, if you do use the
+   macros you must recompile your extensions with each Python release.
+
+   Never mix calls to PyObject_ memory functions with calls to the platform
+   malloc/realloc/ calloc/free, or with calls to PyMem_.
+*/
+
+/*
+Functions and macros for modules that implement new object types.
+
+ - PyObject_New(type, typeobj) allocates memory for a new object of the given
+   type, and initializes part of it.  'type' must be the C structure type used
+   to represent the object, and 'typeobj' the address of the corresponding
+   type object.  Reference count and type pointer are filled in; the rest of
+   the bytes of the object are *undefined*!  The resulting expression type is
+   'type *'.  The size of the object is determined by the tp_basicsize field
+   of the type object.
+
+ - PyObject_NewVar(type, typeobj, n) is similar but allocates a variable-size
+   object with room for n items.  In addition to the refcount and type pointer
+   fields, this also fills in the ob_size field.
+
+ - PyObject_Del(op) releases the memory allocated for an object.  It does not
+   run a destructor -- it only frees the memory.  PyObject_Free is identical.
+
+ - PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) don't
+   allocate memory.  Instead of a 'type' parameter, they take a pointer to a
+   new object (allocated by an arbitrary allocator), and initialize its object
+   header fields.
+
+Note that objects created with PyObject_{New, NewVar} are allocated using the
+specialized Python allocator (implemented in obmalloc.c), if WITH_PYMALLOC is
+enabled.  In addition, a special debugging allocator is used if PYMALLOC_DEBUG
+is also #defined.
+
+In case a specific form of memory management is needed (for example, if you
+must use the platform malloc heap(s), or shared memory, or C++ local storage or
+operator new), you must first allocate the object with your custom allocator,
+then pass its pointer to PyObject_{Init, InitVar} for filling in its Python-
+specific fields:  reference count, type pointer, possibly others.  You should
+be aware that Python has no control over these objects because they don't
+cooperate with the Python memory manager.  Such objects may not be eligible
+for automatic garbage collection and you have to make sure that they are
+released accordingly whenever their destructor gets called (cf. the specific
+form of memory management you're using).
+
+Unless you have specific memory management requirements, use
+PyObject_{New, NewVar, Del}.
+*/
+
+/*
+ * Raw object memory interface
+ * ===========================
+ */
+
+/* Functions to call the same malloc/realloc/free as used by Python's
+   object allocator.  If WITH_PYMALLOC is enabled, these may differ from
+   the platform malloc/realloc/free.  The Python object allocator is
+   designed for fast, cache-conscious allocation of many "small" objects,
+   and with low hidden memory overhead.
+
+   PyObject_Malloc(0) returns a unique non-NULL pointer if possible.
+
+   PyObject_Realloc(NULL, n) acts like PyObject_Malloc(n).
+   PyObject_Realloc(p != NULL, 0) does not return  NULL, or free the memory
+   at p.
+
+   Returned pointers must be checked for NULL explicitly; no action is
+   performed on failure other than to return NULL (no warning it printed, no
+   exception is set, etc).
+
+   For allocating objects, use PyObject_{New, NewVar} instead whenever
+   possible.  The PyObject_{Malloc, Realloc, Free} family is exposed
+   so that you can exploit Python's small-block allocator for non-object
+   uses.  If you must use these routines to allocate object memory, make sure
+   the object gets initialized via PyObject_{Init, InitVar} after obtaining
+   the raw memory.
+*/
+PyAPI_FUNC(void *) PyObject_Malloc(size_t size);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_FUNC(void *) PyObject_Calloc(size_t nelem, size_t elsize);
+#endif
+PyAPI_FUNC(void *) PyObject_Realloc(void *ptr, size_t new_size);
+PyAPI_FUNC(void) PyObject_Free(void *ptr);
+
+
+/* Macros */
+#define PyObject_MALLOC         PyObject_Malloc
+#define PyObject_REALLOC        PyObject_Realloc
+#define PyObject_FREE           PyObject_Free
+#define PyObject_Del            PyObject_Free
+#define PyObject_DEL            PyObject_Free
+
+
+/*
+ * Generic object allocator interface
+ * ==================================
+ */
+
+/* Functions */
+PyAPI_FUNC(PyObject *) PyObject_Init(PyObject *, PyTypeObject *);
+PyAPI_FUNC(PyVarObject *) PyObject_InitVar(PyVarObject *,
+                                                 PyTypeObject *, Py_ssize_t);
+PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *);
+PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
+
+#define PyObject_New(type, typeobj) ((type *)_PyObject_New(typeobj))
+
+// Alias to PyObject_New(). In Python 3.8, PyObject_NEW() called directly
+// PyObject_MALLOC() with _PyObject_SIZE().
+#define PyObject_NEW(type, typeobj) PyObject_New(type, typeobj)
+
+#define PyObject_NewVar(type, typeobj, n) \
+                ( (type *) _PyObject_NewVar((typeobj), (n)) )
+
+// Alias to PyObject_New(). In Python 3.8, PyObject_NEW() called directly
+// PyObject_MALLOC() with _PyObject_VAR_SIZE().
+#define PyObject_NEW_VAR(type, typeobj, n) PyObject_NewVar(type, typeobj, n)
+
+
+#ifdef Py_LIMITED_API
+/* Define PyObject_INIT() and PyObject_INIT_VAR() as aliases to PyObject_Init()
+   and PyObject_InitVar() in the limited C API for compatibility with the
+   CPython C API. */
+#  define PyObject_INIT(op, typeobj) \
+        PyObject_Init(_PyObject_CAST(op), (typeobj))
+#  define PyObject_INIT_VAR(op, typeobj, size) \
+        PyObject_InitVar(_PyVarObject_CAST(op), (typeobj), (size))
+#else
+/* PyObject_INIT() and PyObject_INIT_VAR() are defined in cpython/objimpl.h */
+#endif
+
+
+/*
+ * Garbage Collection Support
+ * ==========================
+ */
+
+/* C equivalent of gc.collect() which ignores the state of gc.enabled. */
+PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void);
+
+/* Test if a type has a GC head */
+#define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)
+
+PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t);
+#define PyObject_GC_Resize(type, op, n) \
+                ( (type *) _PyObject_GC_Resize(_PyVarObject_CAST(op), (n)) )
+
+
+
+PyAPI_FUNC(PyObject *) _PyObject_GC_New(PyTypeObject *);
+PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t);
+
+/* Tell the GC to track this object.
+ *
+ * See also private _PyObject_GC_TRACK() macro. */
+PyAPI_FUNC(void) PyObject_GC_Track(void *);
+
+/* Tell the GC to stop tracking this object.
+ *
+ * See also private _PyObject_GC_UNTRACK() macro. */
+PyAPI_FUNC(void) PyObject_GC_UnTrack(void *);
+
+PyAPI_FUNC(void) PyObject_GC_Del(void *);
+
+#define PyObject_GC_New(type, typeobj) \
+                ( (type *) _PyObject_GC_New(typeobj) )
+#define PyObject_GC_NewVar(type, typeobj, n) \
+                ( (type *) _PyObject_GC_NewVar((typeobj), (n)) )
+
+PyAPI_FUNC(int) PyObject_GC_IsTracked(PyObject *);
+PyAPI_FUNC(int) PyObject_GC_IsFinalized(PyObject *);
+
+/* Utility macro to help write tp_traverse functions.
+ * To use this macro, the tp_traverse function must name its arguments
+ * "visit" and "arg".  This is intended to keep tp_traverse functions
+ * looking as much alike as possible.
+ */
+#define Py_VISIT(op)                                                    \
+    do {                                                                \
+        if (op) {                                                       \
+            int vret = visit(_PyObject_CAST(op), arg);                  \
+            if (vret)                                                   \
+                return vret;                                            \
+        }                                                               \
+    } while (0)
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_OBJIMPL_H
+#  include  "cpython/objimpl.h"
+#  undef Py_CPYTHON_OBJIMPL_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_OBJIMPL_H */
diff --git a/marketing/include/odictobject.h b/marketing/include/odictobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..e070413017d801c8c41d430cfb8431371987bf45
--- /dev/null
+++ b/marketing/include/odictobject.h
@@ -0,0 +1,43 @@
+#ifndef Py_ODICTOBJECT_H
+#define Py_ODICTOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* OrderedDict */
+/* This API is optional and mostly redundant. */
+
+#ifndef Py_LIMITED_API
+
+typedef struct _odictobject PyODictObject;
+
+PyAPI_DATA(PyTypeObject) PyODict_Type;
+PyAPI_DATA(PyTypeObject) PyODictIter_Type;
+PyAPI_DATA(PyTypeObject) PyODictKeys_Type;
+PyAPI_DATA(PyTypeObject) PyODictItems_Type;
+PyAPI_DATA(PyTypeObject) PyODictValues_Type;
+
+#define PyODict_Check(op) PyObject_TypeCheck(op, &PyODict_Type)
+#define PyODict_CheckExact(op) Py_IS_TYPE(op, &PyODict_Type)
+#define PyODict_SIZE(op) PyDict_GET_SIZE((op))
+
+PyAPI_FUNC(PyObject *) PyODict_New(void);
+PyAPI_FUNC(int) PyODict_SetItem(PyObject *od, PyObject *key, PyObject *item);
+PyAPI_FUNC(int) PyODict_DelItem(PyObject *od, PyObject *key);
+
+/* wrappers around PyDict* functions */
+#define PyODict_GetItem(od, key) PyDict_GetItem(_PyObject_CAST(od), key)
+#define PyODict_GetItemWithError(od, key) \
+    PyDict_GetItemWithError(_PyObject_CAST(od), key)
+#define PyODict_Contains(od, key) PyDict_Contains(_PyObject_CAST(od), key)
+#define PyODict_Size(od) PyDict_Size(_PyObject_CAST(od))
+#define PyODict_GetItemString(od, key) \
+    PyDict_GetItemString(_PyObject_CAST(od), key)
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_ODICTOBJECT_H */
diff --git a/marketing/include/opcode.h b/marketing/include/opcode.h
new file mode 100644
index 0000000000000000000000000000000000000000..19944fac0b9f2b36fb3998fd2c4c7775c934d872
--- /dev/null
+++ b/marketing/include/opcode.h
@@ -0,0 +1,142 @@
+/* Auto-generated by Tools/scripts/generate_opcode_h.py from Lib/opcode.py */
+#ifndef Py_OPCODE_H
+#define Py_OPCODE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+    /* Instruction opcodes for compiled code */
+#define POP_TOP                   1
+#define ROT_TWO                   2
+#define ROT_THREE                 3
+#define DUP_TOP                   4
+#define DUP_TOP_TWO               5
+#define ROT_FOUR                  6
+#define NOP                       9
+#define UNARY_POSITIVE           10
+#define UNARY_NEGATIVE           11
+#define UNARY_NOT                12
+#define UNARY_INVERT             15
+#define BINARY_MATRIX_MULTIPLY   16
+#define INPLACE_MATRIX_MULTIPLY  17
+#define BINARY_POWER             19
+#define BINARY_MULTIPLY          20
+#define BINARY_MODULO            22
+#define BINARY_ADD               23
+#define BINARY_SUBTRACT          24
+#define BINARY_SUBSCR            25
+#define BINARY_FLOOR_DIVIDE      26
+#define BINARY_TRUE_DIVIDE       27
+#define INPLACE_FLOOR_DIVIDE     28
+#define INPLACE_TRUE_DIVIDE      29
+#define RERAISE                  48
+#define WITH_EXCEPT_START        49
+#define GET_AITER                50
+#define GET_ANEXT                51
+#define BEFORE_ASYNC_WITH        52
+#define END_ASYNC_FOR            54
+#define INPLACE_ADD              55
+#define INPLACE_SUBTRACT         56
+#define INPLACE_MULTIPLY         57
+#define INPLACE_MODULO           59
+#define STORE_SUBSCR             60
+#define DELETE_SUBSCR            61
+#define BINARY_LSHIFT            62
+#define BINARY_RSHIFT            63
+#define BINARY_AND               64
+#define BINARY_XOR               65
+#define BINARY_OR                66
+#define INPLACE_POWER            67
+#define GET_ITER                 68
+#define GET_YIELD_FROM_ITER      69
+#define PRINT_EXPR               70
+#define LOAD_BUILD_CLASS         71
+#define YIELD_FROM               72
+#define GET_AWAITABLE            73
+#define LOAD_ASSERTION_ERROR     74
+#define INPLACE_LSHIFT           75
+#define INPLACE_RSHIFT           76
+#define INPLACE_AND              77
+#define INPLACE_XOR              78
+#define INPLACE_OR               79
+#define LIST_TO_TUPLE            82
+#define RETURN_VALUE             83
+#define IMPORT_STAR              84
+#define SETUP_ANNOTATIONS        85
+#define YIELD_VALUE              86
+#define POP_BLOCK                87
+#define POP_EXCEPT               89
+#define HAVE_ARGUMENT            90
+#define STORE_NAME               90
+#define DELETE_NAME              91
+#define UNPACK_SEQUENCE          92
+#define FOR_ITER                 93
+#define UNPACK_EX                94
+#define STORE_ATTR               95
+#define DELETE_ATTR              96
+#define STORE_GLOBAL             97
+#define DELETE_GLOBAL            98
+#define LOAD_CONST              100
+#define LOAD_NAME               101
+#define BUILD_TUPLE             102
+#define BUILD_LIST              103
+#define BUILD_SET               104
+#define BUILD_MAP               105
+#define LOAD_ATTR               106
+#define COMPARE_OP              107
+#define IMPORT_NAME             108
+#define IMPORT_FROM             109
+#define JUMP_FORWARD            110
+#define JUMP_IF_FALSE_OR_POP    111
+#define JUMP_IF_TRUE_OR_POP     112
+#define JUMP_ABSOLUTE           113
+#define POP_JUMP_IF_FALSE       114
+#define POP_JUMP_IF_TRUE        115
+#define LOAD_GLOBAL             116
+#define IS_OP                   117
+#define CONTAINS_OP             118
+#define JUMP_IF_NOT_EXC_MATCH   121
+#define SETUP_FINALLY           122
+#define LOAD_FAST               124
+#define STORE_FAST              125
+#define DELETE_FAST             126
+#define RAISE_VARARGS           130
+#define CALL_FUNCTION           131
+#define MAKE_FUNCTION           132
+#define BUILD_SLICE             133
+#define LOAD_CLOSURE            135
+#define LOAD_DEREF              136
+#define STORE_DEREF             137
+#define DELETE_DEREF            138
+#define CALL_FUNCTION_KW        141
+#define CALL_FUNCTION_EX        142
+#define SETUP_WITH              143
+#define EXTENDED_ARG            144
+#define LIST_APPEND             145
+#define SET_ADD                 146
+#define MAP_ADD                 147
+#define LOAD_CLASSDEREF         148
+#define SETUP_ASYNC_WITH        154
+#define FORMAT_VALUE            155
+#define BUILD_CONST_KEY_MAP     156
+#define BUILD_STRING            157
+#define LOAD_METHOD             160
+#define CALL_METHOD             161
+#define LIST_EXTEND             162
+#define SET_UPDATE              163
+#define DICT_MERGE              164
+#define DICT_UPDATE             165
+
+/* EXCEPT_HANDLER is a special, implicit block type which is created when
+   entering an except handler. It is not an opcode but we define it here
+   as we want it to be available to both frameobject.c and ceval.c, while
+   remaining private.*/
+#define EXCEPT_HANDLER 257
+
+#define HAS_ARG(op) ((op) >= HAVE_ARGUMENT)
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_OPCODE_H */
diff --git a/marketing/include/osdefs.h b/marketing/include/osdefs.h
new file mode 100644
index 0000000000000000000000000000000000000000..3243944a1483e95904b4d7d75d0e152ac00824e5
--- /dev/null
+++ b/marketing/include/osdefs.h
@@ -0,0 +1,51 @@
+#ifndef Py_OSDEFS_H
+#define Py_OSDEFS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Operating system dependencies */
+
+#ifdef MS_WINDOWS
+#define SEP L'\\'
+#define ALTSEP L'/'
+#define MAXPATHLEN 256
+#define DELIM L';'
+#endif
+
+#ifdef __VXWORKS__
+#define DELIM L';'
+#endif
+
+/* Filename separator */
+#ifndef SEP
+#define SEP L'/'
+#endif
+
+/* Max pathname length */
+#ifdef __hpux
+#include 
+#include 
+#ifndef PATH_MAX
+#define PATH_MAX MAXPATHLEN
+#endif
+#endif
+
+#ifndef MAXPATHLEN
+#if defined(PATH_MAX) && PATH_MAX > 1024
+#define MAXPATHLEN PATH_MAX
+#else
+#define MAXPATHLEN 1024
+#endif
+#endif
+
+/* Search path entry delimiter */
+#ifndef DELIM
+#define DELIM L':'
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_OSDEFS_H */
diff --git a/marketing/include/osmodule.h b/marketing/include/osmodule.h
new file mode 100644
index 0000000000000000000000000000000000000000..9095c2fdd3d638140db129937d29830286941819
--- /dev/null
+++ b/marketing/include/osmodule.h
@@ -0,0 +1,17 @@
+
+/* os module interface */
+
+#ifndef Py_OSMODULE_H
+#define Py_OSMODULE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+PyAPI_FUNC(PyObject *) PyOS_FSPath(PyObject *path);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_OSMODULE_H */
diff --git a/marketing/include/parsetok.h b/marketing/include/parsetok.h
new file mode 100644
index 0000000000000000000000000000000000000000..935d733e90a5afed7fadbda7596337b169d5fd50
--- /dev/null
+++ b/marketing/include/parsetok.h
@@ -0,0 +1,110 @@
+/* Parser-tokenizer link interface */
+
+#ifndef Py_LIMITED_API
+#ifndef Py_PARSETOK_H
+#define Py_PARSETOK_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "grammar.h"      /* grammar */
+#include "node.h"         /* node */
+
+typedef struct {
+    int error;
+    PyObject *filename;
+    int lineno;
+    int offset;
+    char *text;                 /* UTF-8-encoded string */
+    int token;
+    int expected;
+} perrdetail;
+
+#if 0
+#define PyPARSE_YIELD_IS_KEYWORD        0x0001
+#endif
+
+#define PyPARSE_DONT_IMPLY_DEDENT       0x0002
+
+#if 0
+#define PyPARSE_WITH_IS_KEYWORD         0x0003
+#define PyPARSE_PRINT_IS_FUNCTION       0x0004
+#define PyPARSE_UNICODE_LITERALS        0x0008
+#endif
+
+#define PyPARSE_IGNORE_COOKIE 0x0010
+#define PyPARSE_BARRY_AS_BDFL 0x0020
+#define PyPARSE_TYPE_COMMENTS 0x0040
+#define PyPARSE_ASYNC_HACKS   0x0080
+
+PyAPI_FUNC(node *) PyParser_ParseString(const char *, grammar *, int,
+                                              perrdetail *);
+PyAPI_FUNC(node *) PyParser_ParseFile (FILE *, const char *, grammar *, int,
+                                             const char *, const char *,
+                                             perrdetail *);
+
+PyAPI_FUNC(node *) PyParser_ParseStringFlags(const char *, grammar *, int,
+                                              perrdetail *, int);
+PyAPI_FUNC(node *) PyParser_ParseFileFlags(
+    FILE *fp,
+    const char *filename,       /* decoded from the filesystem encoding */
+    const char *enc,
+    grammar *g,
+    int start,
+    const char *ps1,
+    const char *ps2,
+    perrdetail *err_ret,
+    int flags);
+PyAPI_FUNC(node *) PyParser_ParseFileFlagsEx(
+    FILE *fp,
+    const char *filename,       /* decoded from the filesystem encoding */
+    const char *enc,
+    grammar *g,
+    int start,
+    const char *ps1,
+    const char *ps2,
+    perrdetail *err_ret,
+    int *flags);
+PyAPI_FUNC(node *) PyParser_ParseFileObject(
+    FILE *fp,
+    PyObject *filename,
+    const char *enc,
+    grammar *g,
+    int start,
+    const char *ps1,
+    const char *ps2,
+    perrdetail *err_ret,
+    int *flags);
+
+PyAPI_FUNC(node *) PyParser_ParseStringFlagsFilename(
+    const char *s,
+    const char *filename,       /* decoded from the filesystem encoding */
+    grammar *g,
+    int start,
+    perrdetail *err_ret,
+    int flags);
+PyAPI_FUNC(node *) PyParser_ParseStringFlagsFilenameEx(
+    const char *s,
+    const char *filename,       /* decoded from the filesystem encoding */
+    grammar *g,
+    int start,
+    perrdetail *err_ret,
+    int *flags);
+PyAPI_FUNC(node *) PyParser_ParseStringObject(
+    const char *s,
+    PyObject *filename,
+    grammar *g,
+    int start,
+    perrdetail *err_ret,
+    int *flags);
+
+/* Note that the following functions are defined in pythonrun.c,
+   not in parsetok.c */
+PyAPI_FUNC(void) PyParser_SetError(perrdetail *);
+PyAPI_FUNC(void) PyParser_ClearError(perrdetail *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PARSETOK_H */
+#endif /* !Py_LIMITED_API */
diff --git a/marketing/include/patchlevel.h b/marketing/include/patchlevel.h
new file mode 100644
index 0000000000000000000000000000000000000000..3fe9d1bbb48f44c0326515162e95b2fbb2a14ef7
--- /dev/null
+++ b/marketing/include/patchlevel.h
@@ -0,0 +1,35 @@
+
+/* Python version identification scheme.
+
+   When the major or minor version changes, the VERSION variable in
+   configure.ac must also be changed.
+
+   There is also (independent) API version information in modsupport.h.
+*/
+
+/* Values for PY_RELEASE_LEVEL */
+#define PY_RELEASE_LEVEL_ALPHA  0xA
+#define PY_RELEASE_LEVEL_BETA   0xB
+#define PY_RELEASE_LEVEL_GAMMA  0xC     /* For release candidates */
+#define PY_RELEASE_LEVEL_FINAL  0xF     /* Serial should be 0 here */
+                                        /* Higher for patch releases */
+
+/* Version parsed out into numeric values */
+/*--start constants--*/
+#define PY_MAJOR_VERSION        3
+#define PY_MINOR_VERSION        9
+#define PY_MICRO_VERSION        21
+#define PY_RELEASE_LEVEL        PY_RELEASE_LEVEL_FINAL
+#define PY_RELEASE_SERIAL       0
+
+/* Version as a string */
+#define PY_VERSION              "3.9.21"
+/*--end constants--*/
+
+/* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2.
+   Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */
+#define PY_VERSION_HEX ((PY_MAJOR_VERSION << 24) | \
+                        (PY_MINOR_VERSION << 16) | \
+                        (PY_MICRO_VERSION <<  8) | \
+                        (PY_RELEASE_LEVEL <<  4) | \
+                        (PY_RELEASE_SERIAL << 0))
diff --git a/marketing/include/picklebufobject.h b/marketing/include/picklebufobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..0df2561dceaea04a9942b2aae18762dfc2fe806d
--- /dev/null
+++ b/marketing/include/picklebufobject.h
@@ -0,0 +1,31 @@
+/* PickleBuffer object. This is built-in for ease of use from third-party
+ * C extensions.
+ */
+
+#ifndef Py_PICKLEBUFOBJECT_H
+#define Py_PICKLEBUFOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+
+PyAPI_DATA(PyTypeObject) PyPickleBuffer_Type;
+
+#define PyPickleBuffer_Check(op) Py_IS_TYPE(op, &PyPickleBuffer_Type)
+
+/* Create a PickleBuffer redirecting to the given buffer-enabled object */
+PyAPI_FUNC(PyObject *) PyPickleBuffer_FromObject(PyObject *);
+/* Get the PickleBuffer's underlying view to the original object
+ * (NULL if released)
+ */
+PyAPI_FUNC(const Py_buffer *) PyPickleBuffer_GetBuffer(PyObject *);
+/* Release the PickleBuffer.  Returns 0 on success, -1 on error. */
+PyAPI_FUNC(int) PyPickleBuffer_Release(PyObject *);
+
+#endif /* !Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PICKLEBUFOBJECT_H */
diff --git a/marketing/include/py_curses.h b/marketing/include/py_curses.h
new file mode 100644
index 0000000000000000000000000000000000000000..b70252d9d7605eb315aacc5a1abf10993a054eac
--- /dev/null
+++ b/marketing/include/py_curses.h
@@ -0,0 +1,99 @@
+
+#ifndef Py_CURSES_H
+#define Py_CURSES_H
+
+#ifdef __APPLE__
+/*
+** On Mac OS X 10.2 [n]curses.h and stdlib.h use different guards
+** against multiple definition of wchar_t.
+*/
+#ifdef _BSD_WCHAR_T_DEFINED_
+#define _WCHAR_T
+#endif
+#endif /* __APPLE__ */
+
+/* On FreeBSD, [n]curses.h and stdlib.h/wchar.h use different guards
+   against multiple definition of wchar_t and wint_t. */
+#if defined(__FreeBSD__) && defined(_XOPEN_SOURCE_EXTENDED)
+# ifndef __wchar_t
+#   define __wchar_t
+# endif
+# ifndef __wint_t
+#   define __wint_t
+# endif
+#endif
+
+#if !defined(HAVE_CURSES_IS_PAD) && defined(WINDOW_HAS_FLAGS)
+/* The following definition is necessary for ncurses 5.7; without it,
+   some of [n]curses.h set NCURSES_OPAQUE to 1, and then Python
+   can't get at the WINDOW flags field. */
+#define NCURSES_OPAQUE 0
+#endif
+
+#ifdef HAVE_NCURSES_H
+#include 
+#else
+#include 
+#endif
+
+#ifdef HAVE_NCURSES_H
+/* configure was checking , but we will
+   use , which has some or all these features. */
+#if !defined(WINDOW_HAS_FLAGS) && !(NCURSES_OPAQUE+0)
+#define WINDOW_HAS_FLAGS 1
+#endif
+#if !defined(HAVE_CURSES_IS_PAD) && NCURSES_VERSION_PATCH+0 >= 20090906
+#define HAVE_CURSES_IS_PAD 1
+#endif
+#ifndef MVWDELCH_IS_EXPRESSION
+#define MVWDELCH_IS_EXPRESSION 1
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PyCurses_API_pointers 4
+
+/* Type declarations */
+
+typedef struct {
+    PyObject_HEAD
+    WINDOW *win;
+    char *encoding;
+} PyCursesWindowObject;
+
+#define PyCursesWindow_Check(v) Py_IS_TYPE(v, &PyCursesWindow_Type)
+
+#define PyCurses_CAPSULE_NAME "_curses._C_API"
+
+
+#ifdef CURSES_MODULE
+/* This section is used when compiling _cursesmodule.c */
+
+#else
+/* This section is used in modules that use the _cursesmodule API */
+
+static void **PyCurses_API;
+
+#define PyCursesWindow_Type (*(PyTypeObject *) PyCurses_API[0])
+#define PyCursesSetupTermCalled  {if (! ((int (*)(void))PyCurses_API[1]) () ) return NULL;}
+#define PyCursesInitialised      {if (! ((int (*)(void))PyCurses_API[2]) () ) return NULL;}
+#define PyCursesInitialisedColor {if (! ((int (*)(void))PyCurses_API[3]) () ) return NULL;}
+
+#define import_curses() \
+    PyCurses_API = (void **)PyCapsule_Import(PyCurses_CAPSULE_NAME, 1);
+
+#endif
+
+/* general error messages */
+static const char catchall_ERR[]  = "curses function returned ERR";
+static const char catchall_NULL[] = "curses function returned NULL";
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !defined(Py_CURSES_H) */
+
diff --git a/marketing/include/pyarena.h b/marketing/include/pyarena.h
new file mode 100644
index 0000000000000000000000000000000000000000..db3ad0188fe1cd9f685d7c27d3869adae912d574
--- /dev/null
+++ b/marketing/include/pyarena.h
@@ -0,0 +1,64 @@
+/* An arena-like memory interface for the compiler.
+ */
+
+#ifndef Py_LIMITED_API
+#ifndef Py_PYARENA_H
+#define Py_PYARENA_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  typedef struct _arena PyArena;
+
+  /* PyArena_New() and PyArena_Free() create a new arena and free it,
+     respectively.  Once an arena has been created, it can be used
+     to allocate memory via PyArena_Malloc().  Pointers to PyObject can
+     also be registered with the arena via PyArena_AddPyObject(), and the
+     arena will ensure that the PyObjects stay alive at least until
+     PyArena_Free() is called.  When an arena is freed, all the memory it
+     allocated is freed, the arena releases internal references to registered
+     PyObject*, and none of its pointers are valid.
+     XXX (tim) What does "none of its pointers are valid" mean?  Does it
+     XXX mean that pointers previously obtained via PyArena_Malloc() are
+     XXX no longer valid?  (That's clearly true, but not sure that's what
+     XXX the text is trying to say.)
+
+     PyArena_New() returns an arena pointer.  On error, it
+     returns a negative number and sets an exception.
+     XXX (tim):  Not true.  On error, PyArena_New() actually returns NULL,
+     XXX and looks like it may or may not set an exception (e.g., if the
+     XXX internal PyList_New(0) returns NULL, PyArena_New() passes that on
+     XXX and an exception is set; OTOH, if the internal
+     XXX block_new(DEFAULT_BLOCK_SIZE) returns NULL, that's passed on but
+     XXX an exception is not set in that case).
+  */
+  PyAPI_FUNC(PyArena *) PyArena_New(void);
+  PyAPI_FUNC(void) PyArena_Free(PyArena *);
+
+  /* Mostly like malloc(), return the address of a block of memory spanning
+   * `size` bytes, or return NULL (without setting an exception) if enough
+   * new memory can't be obtained.  Unlike malloc(0), PyArena_Malloc() with
+   * size=0 does not guarantee to return a unique pointer (the pointer
+   * returned may equal one or more other pointers obtained from
+   * PyArena_Malloc()).
+   * Note that pointers obtained via PyArena_Malloc() must never be passed to
+   * the system free() or realloc(), or to any of Python's similar memory-
+   * management functions.  PyArena_Malloc()-obtained pointers remain valid
+   * until PyArena_Free(ar) is called, at which point all pointers obtained
+   * from the arena `ar` become invalid simultaneously.
+   */
+  PyAPI_FUNC(void *) PyArena_Malloc(PyArena *, size_t size);
+
+  /* This routine isn't a proper arena allocation routine.  It takes
+   * a PyObject* and records it so that it can be DECREFed when the
+   * arena is freed.
+   */
+  PyAPI_FUNC(int) PyArena_AddPyObject(PyArena *, PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_PYARENA_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/pycapsule.h b/marketing/include/pycapsule.h
new file mode 100644
index 0000000000000000000000000000000000000000..fb5d503fea73f13a254dc51b003e703b511250dd
--- /dev/null
+++ b/marketing/include/pycapsule.h
@@ -0,0 +1,59 @@
+
+/* Capsule objects let you wrap a C "void *" pointer in a Python
+   object.  They're a way of passing data through the Python interpreter
+   without creating your own custom type.
+
+   Capsules are used for communication between extension modules.
+   They provide a way for an extension module to export a C interface
+   to other extension modules, so that extension modules can use the
+   Python import mechanism to link to one another.
+
+   For more information, please see "c-api/capsule.html" in the
+   documentation.
+*/
+
+#ifndef Py_CAPSULE_H
+#define Py_CAPSULE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyCapsule_Type;
+
+typedef void (*PyCapsule_Destructor)(PyObject *);
+
+#define PyCapsule_CheckExact(op) Py_IS_TYPE(op, &PyCapsule_Type)
+
+
+PyAPI_FUNC(PyObject *) PyCapsule_New(
+    void *pointer,
+    const char *name,
+    PyCapsule_Destructor destructor);
+
+PyAPI_FUNC(void *) PyCapsule_GetPointer(PyObject *capsule, const char *name);
+
+PyAPI_FUNC(PyCapsule_Destructor) PyCapsule_GetDestructor(PyObject *capsule);
+
+PyAPI_FUNC(const char *) PyCapsule_GetName(PyObject *capsule);
+
+PyAPI_FUNC(void *) PyCapsule_GetContext(PyObject *capsule);
+
+PyAPI_FUNC(int) PyCapsule_IsValid(PyObject *capsule, const char *name);
+
+PyAPI_FUNC(int) PyCapsule_SetPointer(PyObject *capsule, void *pointer);
+
+PyAPI_FUNC(int) PyCapsule_SetDestructor(PyObject *capsule, PyCapsule_Destructor destructor);
+
+PyAPI_FUNC(int) PyCapsule_SetName(PyObject *capsule, const char *name);
+
+PyAPI_FUNC(int) PyCapsule_SetContext(PyObject *capsule, void *context);
+
+PyAPI_FUNC(void *) PyCapsule_Import(
+    const char *name,           /* UTF-8 encoded string */
+    int no_block);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CAPSULE_H */
diff --git a/marketing/include/pyconfig.h b/marketing/include/pyconfig.h
new file mode 100644
index 0000000000000000000000000000000000000000..d7d3cf081e05054150aa0413c73dcac6704af26b
--- /dev/null
+++ b/marketing/include/pyconfig.h
@@ -0,0 +1,687 @@
+#ifndef Py_CONFIG_H
+#define Py_CONFIG_H
+
+/* pyconfig.h.  NOT Generated automatically by configure.
+
+This is a manually maintained version used for the Watcom,
+Borland and Microsoft Visual C++ compilers.  It is a
+standard part of the Python distribution.
+
+WINDOWS DEFINES:
+The code specific to Windows should be wrapped around one of
+the following #defines
+
+MS_WIN64 - Code specific to the MS Win64 API
+MS_WIN32 - Code specific to the MS Win32 (and Win64) API (obsolete, this covers all supported APIs)
+MS_WINDOWS - Code specific to Windows, but all versions.
+Py_ENABLE_SHARED - Code if the Python core is built as a DLL.
+
+Also note that neither "_M_IX86" or "_MSC_VER" should be used for
+any purpose other than "Windows Intel x86 specific" and "Microsoft
+compiler specific".  Therefore, these should be very rare.
+
+
+NOTE: The following symbols are deprecated:
+NT, USE_DL_EXPORT, USE_DL_IMPORT, DL_EXPORT, DL_IMPORT
+MS_CORE_DLL.
+
+WIN32 is still required for the locale module.
+
+*/
+
+/* Deprecated USE_DL_EXPORT macro - please use Py_BUILD_CORE */
+#ifdef USE_DL_EXPORT
+#       define Py_BUILD_CORE
+#endif /* USE_DL_EXPORT */
+
+/* Visual Studio 2005 introduces deprecation warnings for
+   "insecure" and POSIX functions. The insecure functions should
+   be replaced by *_s versions (according to Microsoft); the
+   POSIX functions by _* versions (which, according to Microsoft,
+   would be ISO C conforming). Neither renaming is feasible, so
+   we just silence the warnings. */
+
+#ifndef _CRT_SECURE_NO_DEPRECATE
+#define _CRT_SECURE_NO_DEPRECATE 1
+#endif
+#ifndef _CRT_NONSTDC_NO_DEPRECATE
+#define _CRT_NONSTDC_NO_DEPRECATE 1
+#endif
+
+#define HAVE_IO_H
+#define HAVE_SYS_UTIME_H
+#define HAVE_TEMPNAM
+#define HAVE_TMPFILE
+#define HAVE_TMPNAM
+#define HAVE_CLOCK
+#define HAVE_STRERROR
+
+#include 
+
+#define HAVE_HYPOT
+#define HAVE_STRFTIME
+#define DONT_HAVE_SIG_ALARM
+#define DONT_HAVE_SIG_PAUSE
+#define LONG_BIT        32
+#define WORD_BIT 32
+
+#define MS_WIN32 /* only support win32 and greater. */
+#define MS_WINDOWS
+#ifndef PYTHONPATH
+#       define PYTHONPATH L".\\DLLs;.\\lib"
+#endif
+#define NT_THREADS
+#define WITH_THREAD
+#ifndef NETSCAPE_PI
+#define USE_SOCKET
+#endif
+
+
+/* Compiler specific defines */
+
+/* ------------------------------------------------------------------------*/
+/* Microsoft C defines _MSC_VER */
+#ifdef _MSC_VER
+
+/* We want COMPILER to expand to a string containing _MSC_VER's *value*.
+ * This is horridly tricky, because the stringization operator only works
+ * on macro arguments, and doesn't evaluate macros passed *as* arguments.
+ * Attempts simpler than the following appear doomed to produce "_MSC_VER"
+ * literally in the string.
+ */
+#define _Py_PASTE_VERSION(SUFFIX) \
+        ("[MSC v." _Py_STRINGIZE(_MSC_VER) " " SUFFIX "]")
+/* e.g., this produces, after compile-time string catenation,
+ *      ("[MSC v.1200 32 bit (Intel)]")
+ *
+ * _Py_STRINGIZE(_MSC_VER) expands to
+ * _Py_STRINGIZE1((_MSC_VER)) expands to
+ * _Py_STRINGIZE2(_MSC_VER) but as this call is the result of token-pasting
+ *      it's scanned again for macros and so further expands to (under MSVC 6)
+ * _Py_STRINGIZE2(1200) which then expands to
+ * "1200"
+ */
+#define _Py_STRINGIZE(X) _Py_STRINGIZE1((X))
+#define _Py_STRINGIZE1(X) _Py_STRINGIZE2 ## X
+#define _Py_STRINGIZE2(X) #X
+
+/* MSVC defines _WINxx to differentiate the windows platform types
+
+   Note that for compatibility reasons _WIN32 is defined on Win32
+   *and* on Win64. For the same reasons, in Python, MS_WIN32 is
+   defined on Win32 *and* Win64. Win32 only code must therefore be
+   guarded as follows:
+        #if defined(MS_WIN32) && !defined(MS_WIN64)
+*/
+#ifdef _WIN64
+#define MS_WIN64
+#endif
+
+/* set the COMPILER */
+#ifdef MS_WIN64
+#if defined(_M_X64) || defined(_M_AMD64)
+#if defined(__INTEL_COMPILER)
+#define COMPILER ("[ICC v." _Py_STRINGIZE(__INTEL_COMPILER) " 64 bit (amd64) with MSC v." _Py_STRINGIZE(_MSC_VER) " CRT]")
+#else
+#define COMPILER _Py_PASTE_VERSION("64 bit (AMD64)")
+#endif /* __INTEL_COMPILER */
+#define PYD_PLATFORM_TAG "win_amd64"
+#elif defined(_M_ARM64)
+#define COMPILER _Py_PASTE_VERSION("64 bit (ARM64)")
+#define PYD_PLATFORM_TAG "win_arm64"
+#else
+#define COMPILER _Py_PASTE_VERSION("64 bit (Unknown)")
+#endif
+#endif /* MS_WIN64 */
+
+/* set the version macros for the windows headers */
+/* Python 3.9+ requires Windows 8 or greater */
+#define Py_WINVER 0x0602 /* _WIN32_WINNT_WIN8 */
+#define Py_NTDDI NTDDI_WIN8
+
+/* We only set these values when building Python - we don't want to force
+   these values on extensions, as that will affect the prototypes and
+   structures exposed in the Windows headers. Even when building Python, we
+   allow a single source file to override this - they may need access to
+   structures etc so it can optionally use new Windows features if it
+   determines at runtime they are available.
+*/
+#if defined(Py_BUILD_CORE) || defined(Py_BUILD_CORE_BUILTIN) || defined(Py_BUILD_CORE_MODULE)
+#ifndef NTDDI_VERSION
+#define NTDDI_VERSION Py_NTDDI
+#endif
+#ifndef WINVER
+#define WINVER Py_WINVER
+#endif
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT Py_WINVER
+#endif
+#endif
+
+/* _W64 is not defined for VC6 or eVC4 */
+#ifndef _W64
+#define _W64
+#endif
+
+/* Define like size_t, omitting the "unsigned" */
+#ifdef MS_WIN64
+typedef __int64 ssize_t;
+#else
+typedef _W64 int ssize_t;
+#endif
+#define HAVE_SSIZE_T 1
+
+#if defined(MS_WIN32) && !defined(MS_WIN64)
+#if defined(_M_IX86)
+#if defined(__INTEL_COMPILER)
+#define COMPILER ("[ICC v." _Py_STRINGIZE(__INTEL_COMPILER) " 32 bit (Intel) with MSC v." _Py_STRINGIZE(_MSC_VER) " CRT]")
+#else
+#define COMPILER _Py_PASTE_VERSION("32 bit (Intel)")
+#endif /* __INTEL_COMPILER */
+#define PYD_PLATFORM_TAG "win32"
+#elif defined(_M_ARM)
+#define COMPILER _Py_PASTE_VERSION("32 bit (ARM)")
+#define PYD_PLATFORM_TAG "win_arm32"
+#else
+#define COMPILER _Py_PASTE_VERSION("32 bit (Unknown)")
+#endif
+#endif /* MS_WIN32 && !MS_WIN64 */
+
+typedef int pid_t;
+
+#include 
+#define Py_IS_NAN _isnan
+#define Py_IS_INFINITY(X) (!_finite(X) && !_isnan(X))
+#define Py_IS_FINITE(X) _finite(X)
+
+/* define some ANSI types that are not defined in earlier Win headers */
+#if _MSC_VER >= 1200
+/* This file only exists in VC 6.0 or higher */
+#include 
+#endif
+
+#endif /* _MSC_VER */
+
+/* ------------------------------------------------------------------------*/
+/* egcs/gnu-win32 defines __GNUC__ and _WIN32 */
+#if defined(__GNUC__) && defined(_WIN32)
+/* XXX These defines are likely incomplete, but should be easy to fix.
+   They should be complete enough to build extension modules. */
+/* Suggested by Rene Liebscher  to avoid a GCC 2.91.*
+   bug that requires structure imports.  More recent versions of the
+   compiler don't exhibit this bug.
+*/
+#if (__GNUC__==2) && (__GNUC_MINOR__<=91)
+#warning "Please use an up-to-date version of gcc! (>2.91 recommended)"
+#endif
+
+#define COMPILER "[gcc]"
+#define PY_LONG_LONG long long
+#define PY_LLONG_MIN LLONG_MIN
+#define PY_LLONG_MAX LLONG_MAX
+#define PY_ULLONG_MAX ULLONG_MAX
+#endif /* GNUC */
+
+/* ------------------------------------------------------------------------*/
+/* lcc-win32 defines __LCC__ */
+#if defined(__LCC__)
+/* XXX These defines are likely incomplete, but should be easy to fix.
+   They should be complete enough to build extension modules. */
+
+#define COMPILER "[lcc-win32]"
+typedef int pid_t;
+/* __declspec() is supported here too - do nothing to get the defaults */
+
+#endif /* LCC */
+
+/* ------------------------------------------------------------------------*/
+/* End of compilers - finish up */
+
+#ifndef NO_STDIO_H
+#       include 
+#endif
+
+/* 64 bit ints are usually spelt __int64 unless compiler has overridden */
+#ifndef PY_LONG_LONG
+#       define PY_LONG_LONG __int64
+#       define PY_LLONG_MAX _I64_MAX
+#       define PY_LLONG_MIN _I64_MIN
+#       define PY_ULLONG_MAX _UI64_MAX
+#endif
+
+/* For Windows the Python core is in a DLL by default.  Test
+Py_NO_ENABLE_SHARED to find out.  Also support MS_NO_COREDLL for b/w compat */
+#if !defined(MS_NO_COREDLL) && !defined(Py_NO_ENABLE_SHARED)
+#       define Py_ENABLE_SHARED 1 /* standard symbol for shared library */
+#       define MS_COREDLL       /* deprecated old symbol */
+#endif /* !MS_NO_COREDLL && ... */
+
+/*  All windows compilers that use this header support __declspec */
+#define HAVE_DECLSPEC_DLL
+
+/* For an MSVC DLL, we can nominate the .lib files used by extensions */
+#ifdef MS_COREDLL
+#       if !defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_BUILTIN)
+                /* not building the core - must be an ext */
+#               if defined(_MSC_VER)
+                        /* So MSVC users need not specify the .lib
+                        file in their Makefile (other compilers are
+                        generally taken care of by distutils.) */
+#                       if defined(_DEBUG)
+#                               pragma comment(lib,"python39_d.lib")
+#                       elif defined(Py_LIMITED_API)
+#                               pragma comment(lib,"python3.lib")
+#                       else
+#                               pragma comment(lib,"python39.lib")
+#                       endif /* _DEBUG */
+#               endif /* _MSC_VER */
+#       endif /* Py_BUILD_CORE */
+#endif /* MS_COREDLL */
+
+#if defined(MS_WIN64)
+/* maintain "win32" sys.platform for backward compatibility of Python code,
+   the Win64 API should be close enough to the Win32 API to make this
+   preferable */
+#       define PLATFORM "win32"
+#       define SIZEOF_VOID_P 8
+#       define SIZEOF_TIME_T 8
+#       define SIZEOF_OFF_T 4
+#       define SIZEOF_FPOS_T 8
+#       define SIZEOF_HKEY 8
+#       define SIZEOF_SIZE_T 8
+/* configure.ac defines HAVE_LARGEFILE_SUPPORT iff
+   sizeof(off_t) > sizeof(long), and sizeof(long long) >= sizeof(off_t).
+   On Win64 the second condition is not true, but if fpos_t replaces off_t
+   then this is true. The uses of HAVE_LARGEFILE_SUPPORT imply that Win64
+   should define this. */
+#       define HAVE_LARGEFILE_SUPPORT
+#elif defined(MS_WIN32)
+#       define PLATFORM "win32"
+#       define HAVE_LARGEFILE_SUPPORT
+#       define SIZEOF_VOID_P 4
+#       define SIZEOF_OFF_T 4
+#       define SIZEOF_FPOS_T 8
+#       define SIZEOF_HKEY 4
+#       define SIZEOF_SIZE_T 4
+        /* MS VS2005 changes time_t to a 64-bit type on all platforms */
+#       if defined(_MSC_VER) && _MSC_VER >= 1400
+#       define SIZEOF_TIME_T 8
+#       else
+#       define SIZEOF_TIME_T 4
+#       endif
+#endif
+
+#ifdef _DEBUG
+#       define Py_DEBUG
+#endif
+
+
+#ifdef MS_WIN32
+
+#define SIZEOF_SHORT 2
+#define SIZEOF_INT 4
+#define SIZEOF_LONG 4
+#define SIZEOF_LONG_LONG 8
+#define SIZEOF_DOUBLE 8
+#define SIZEOF_FLOAT 4
+
+/* VC 7.1 has them and VC 6.0 does not.  VC 6.0 has a version number of 1200.
+   Microsoft eMbedded Visual C++ 4.0 has a version number of 1201 and doesn't
+   define these.
+   If some compiler does not provide them, modify the #if appropriately. */
+#if defined(_MSC_VER)
+#if _MSC_VER > 1300
+#define HAVE_UINTPTR_T 1
+#define HAVE_INTPTR_T 1
+#else
+/* VC6, VS 2002 and eVC4 don't support the C99 LL suffix for 64-bit integer literals */
+#define Py_LL(x) x##I64
+#endif  /* _MSC_VER > 1300  */
+#endif  /* _MSC_VER */
+
+#endif
+
+/* define signed and unsigned exact-width 32-bit and 64-bit types, used in the
+   implementation of Python integers. */
+#define PY_UINT32_T uint32_t
+#define PY_UINT64_T uint64_t
+#define PY_INT32_T int32_t
+#define PY_INT64_T int64_t
+
+/* Fairly standard from here! */
+
+/* Define to 1 if you have the `copysign' function. */
+#define HAVE_COPYSIGN 1
+
+/* Define to 1 if you have the `round' function. */
+#if _MSC_VER >= 1800
+#define HAVE_ROUND 1
+#endif
+
+/* Define to 1 if you have the `isinf' macro. */
+#define HAVE_DECL_ISINF 1
+
+/* Define to 1 if you have the `isnan' function. */
+#define HAVE_DECL_ISNAN 1
+
+/* Define if on AIX 3.
+   System headers sometimes define this.
+   We just want to avoid a redefinition error message.  */
+#ifndef _ALL_SOURCE
+/* #undef _ALL_SOURCE */
+#endif
+
+/* Define to empty if the keyword does not work.  */
+/* #define const  */
+
+/* Define to 1 if you have the  header file. */
+#define HAVE_CONIO_H 1
+
+/* Define to 1 if you have the  header file. */
+#define HAVE_DIRECT_H 1
+
+/* Define to 1 if you have the declaration of `tzname', and to 0 if you don't.
+   */
+#define HAVE_DECL_TZNAME 1
+
+/* Define if you have dirent.h.  */
+/* #define DIRENT 1 */
+
+/* Define to the type of elements in the array set by `getgroups'.
+   Usually this is either `int' or `gid_t'.  */
+/* #undef GETGROUPS_T */
+
+/* Define to `int' if  doesn't define.  */
+/* #undef gid_t */
+
+/* Define if your struct tm has tm_zone.  */
+/* #undef HAVE_TM_ZONE */
+
+/* Define if you don't have tm_zone but do have the external array
+   tzname.  */
+#define HAVE_TZNAME
+
+/* Define to `int' if  doesn't define.  */
+/* #undef mode_t */
+
+/* Define if you don't have dirent.h, but have ndir.h.  */
+/* #undef NDIR */
+
+/* Define to `long' if  doesn't define.  */
+/* #undef off_t */
+
+/* Define to `int' if  doesn't define.  */
+/* #undef pid_t */
+
+/* Define if the system does not provide POSIX.1 features except
+   with this defined.  */
+/* #undef _POSIX_1_SOURCE */
+
+/* Define if you need to in order for stat and other things to work.  */
+/* #undef _POSIX_SOURCE */
+
+/* Define as the return type of signal handlers (int or void).  */
+#define RETSIGTYPE void
+
+/* Define to `unsigned' if  doesn't define.  */
+/* #undef size_t */
+
+/* Define if you have the ANSI C header files.  */
+#define STDC_HEADERS 1
+
+/* Define if you don't have dirent.h, but have sys/dir.h.  */
+/* #undef SYSDIR */
+
+/* Define if you don't have dirent.h, but have sys/ndir.h.  */
+/* #undef SYSNDIR */
+
+/* Define if you can safely include both  and .  */
+/* #undef TIME_WITH_SYS_TIME */
+
+/* Define if your  declares struct tm.  */
+/* #define TM_IN_SYS_TIME 1 */
+
+/* Define to `int' if  doesn't define.  */
+/* #undef uid_t */
+
+/* Define if the closedir function returns void instead of int.  */
+/* #undef VOID_CLOSEDIR */
+
+/* Define if getpgrp() must be called as getpgrp(0)
+   and (consequently) setpgrp() as setpgrp(0, 0). */
+/* #undef GETPGRP_HAVE_ARGS */
+
+/* Define this if your time.h defines altzone */
+/* #define HAVE_ALTZONE */
+
+/* Define if you have the putenv function.  */
+#define HAVE_PUTENV
+
+/* Define if your compiler supports function prototypes */
+#define HAVE_PROTOTYPES
+
+/* Define if  you can safely include both  and 
+   (which you can't on SCO ODT 3.0). */
+/* #undef SYS_SELECT_WITH_SYS_TIME */
+
+/* Define if you want build the _decimal module using a coroutine-local rather
+   than a thread-local context */
+#define WITH_DECIMAL_CONTEXTVAR 1
+
+/* Define if you want documentation strings in extension modules */
+#define WITH_DOC_STRINGS 1
+
+/* Define if you want to compile in rudimentary thread support */
+/* #undef WITH_THREAD */
+
+/* Define if you want to use the GNU readline library */
+/* #define WITH_READLINE 1 */
+
+/* Use Python's own small-block memory-allocator. */
+#define WITH_PYMALLOC 1
+
+/* Define if you have clock.  */
+/* #define HAVE_CLOCK */
+
+/* Define when any dynamic module loading is enabled */
+#define HAVE_DYNAMIC_LOADING
+
+/* Define if you have ftime.  */
+#define HAVE_FTIME
+
+/* Define if you have getpeername.  */
+#define HAVE_GETPEERNAME
+
+/* Define if you have getpgrp.  */
+/* #undef HAVE_GETPGRP */
+
+/* Define if you have getpid.  */
+#define HAVE_GETPID
+
+/* Define if you have gettimeofday.  */
+/* #undef HAVE_GETTIMEOFDAY */
+
+/* Define if you have getwd.  */
+/* #undef HAVE_GETWD */
+
+/* Define if you have lstat.  */
+/* #undef HAVE_LSTAT */
+
+/* Define if you have the mktime function.  */
+#define HAVE_MKTIME
+
+/* Define if you have nice.  */
+/* #undef HAVE_NICE */
+
+/* Define if you have readlink.  */
+/* #undef HAVE_READLINK */
+
+/* Define if you have setpgid.  */
+/* #undef HAVE_SETPGID */
+
+/* Define if you have setpgrp.  */
+/* #undef HAVE_SETPGRP */
+
+/* Define if you have setsid.  */
+/* #undef HAVE_SETSID */
+
+/* Define if you have setvbuf.  */
+#define HAVE_SETVBUF
+
+/* Define if you have siginterrupt.  */
+/* #undef HAVE_SIGINTERRUPT */
+
+/* Define if you have symlink.  */
+/* #undef HAVE_SYMLINK */
+
+/* Define if you have tcgetpgrp.  */
+/* #undef HAVE_TCGETPGRP */
+
+/* Define if you have tcsetpgrp.  */
+/* #undef HAVE_TCSETPGRP */
+
+/* Define if you have times.  */
+/* #undef HAVE_TIMES */
+
+/* Define if you have uname.  */
+/* #undef HAVE_UNAME */
+
+/* Define if you have waitpid.  */
+/* #undef HAVE_WAITPID */
+
+/* Define to 1 if you have the `wcsftime' function. */
+#if defined(_MSC_VER) && _MSC_VER >= 1310
+#define HAVE_WCSFTIME 1
+#endif
+
+/* Define to 1 if you have the `wcscoll' function. */
+#define HAVE_WCSCOLL 1
+
+/* Define to 1 if you have the `wcsxfrm' function. */
+#define HAVE_WCSXFRM 1
+
+/* Define if the zlib library has inflateCopy */
+#define HAVE_ZLIB_COPY 1
+
+/* Define if you have the  header file.  */
+/* #undef HAVE_DLFCN_H */
+
+/* Define to 1 if you have the  header file. */
+#define HAVE_ERRNO_H 1
+
+/* Define if you have the  header file.  */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the  header file. */
+#define HAVE_PROCESS_H 1
+
+/* Define to 1 if you have the  header file. */
+#define HAVE_SIGNAL_H 1
+
+/* Define if you have the  prototypes.  */
+#define HAVE_STDARG_PROTOTYPES
+
+/* Define if you have the  header file.  */
+#define HAVE_STDDEF_H 1
+
+/* Define if you have the  header file.  */
+/* #undef HAVE_SYS_AUDIOIO_H */
+
+/* Define if you have the  header file.  */
+/* #define HAVE_SYS_PARAM_H 1 */
+
+/* Define if you have the  header file.  */
+/* #define HAVE_SYS_SELECT_H 1 */
+
+/* Define to 1 if you have the  header file.  */
+#define HAVE_SYS_STAT_H 1
+
+/* Define if you have the  header file.  */
+/* #define HAVE_SYS_TIME_H 1 */
+
+/* Define if you have the  header file.  */
+/* #define HAVE_SYS_TIMES_H 1 */
+
+/* Define to 1 if you have the  header file.  */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define if you have the  header file.  */
+/* #define HAVE_SYS_UN_H 1 */
+
+/* Define if you have the  header file.  */
+/* #define HAVE_SYS_UTIME_H 1 */
+
+/* Define if you have the  header file.  */
+/* #define HAVE_SYS_UTSNAME_H 1 */
+
+/* Define if you have the  header file.  */
+/* #define HAVE_UNISTD_H 1 */
+
+/* Define if you have the  header file.  */
+/* #define HAVE_UTIME_H 1 */
+
+/* Define if the compiler provides a wchar.h header file. */
+#define HAVE_WCHAR_H 1
+
+/* The size of `wchar_t', as computed by sizeof. */
+#define SIZEOF_WCHAR_T 2
+
+/* The size of `_Bool', as computed by sizeof. */
+#define SIZEOF__BOOL 1
+
+/* The size of `pid_t', as computed by sizeof. */
+#define SIZEOF_PID_T SIZEOF_INT
+
+/* Define if you have the dl library (-ldl).  */
+/* #undef HAVE_LIBDL */
+
+/* Define if you have the mpc library (-lmpc).  */
+/* #undef HAVE_LIBMPC */
+
+/* Define if you have the nsl library (-lnsl).  */
+#define HAVE_LIBNSL 1
+
+/* Define if you have the seq library (-lseq).  */
+/* #undef HAVE_LIBSEQ */
+
+/* Define if you have the socket library (-lsocket).  */
+#define HAVE_LIBSOCKET 1
+
+/* Define if you have the sun library (-lsun).  */
+/* #undef HAVE_LIBSUN */
+
+/* Define if you have the termcap library (-ltermcap).  */
+/* #undef HAVE_LIBTERMCAP */
+
+/* Define if you have the termlib library (-ltermlib).  */
+/* #undef HAVE_LIBTERMLIB */
+
+/* Define if you have the thread library (-lthread).  */
+/* #undef HAVE_LIBTHREAD */
+
+/* WinSock does not use a bitmask in select, and uses
+   socket handles greater than FD_SETSIZE */
+#define Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
+
+/* Define if C doubles are 64-bit IEEE 754 binary format, stored with the
+   least significant byte first */
+#define DOUBLE_IS_LITTLE_ENDIAN_IEEE754 1
+
+/* Define to 1 if you have the `erf' function. */
+#define HAVE_ERF 1
+
+/* Define to 1 if you have the `erfc' function. */
+#define HAVE_ERFC 1
+
+/* Define if you have the 'inet_pton' function. */
+#define HAVE_INET_PTON 1
+
+/* framework name */
+#define _PYTHONFRAMEWORK ""
+
+/* Define if libssl has X509_VERIFY_PARAM_set1_host and related function */
+#define HAVE_X509_VERIFY_PARAM_SET1_HOST 1
+
+#define PLATLIBDIR "lib"
+
+#endif /* !Py_CONFIG_H */
diff --git a/marketing/include/pyctype.h b/marketing/include/pyctype.h
new file mode 100644
index 0000000000000000000000000000000000000000..729d93275e6c5365fb26fd521b1ff58de22b5fdb
--- /dev/null
+++ b/marketing/include/pyctype.h
@@ -0,0 +1,39 @@
+#ifndef Py_LIMITED_API
+#ifndef PYCTYPE_H
+#define PYCTYPE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PY_CTF_LOWER  0x01
+#define PY_CTF_UPPER  0x02
+#define PY_CTF_ALPHA  (PY_CTF_LOWER|PY_CTF_UPPER)
+#define PY_CTF_DIGIT  0x04
+#define PY_CTF_ALNUM  (PY_CTF_ALPHA|PY_CTF_DIGIT)
+#define PY_CTF_SPACE  0x08
+#define PY_CTF_XDIGIT 0x10
+
+PyAPI_DATA(const unsigned int) _Py_ctype_table[256];
+
+/* Unlike their C counterparts, the following macros are not meant to
+ * handle an int with any of the values [EOF, 0-UCHAR_MAX]. The argument
+ * must be a signed/unsigned char. */
+#define Py_ISLOWER(c)  (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_LOWER)
+#define Py_ISUPPER(c)  (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_UPPER)
+#define Py_ISALPHA(c)  (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALPHA)
+#define Py_ISDIGIT(c)  (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_DIGIT)
+#define Py_ISXDIGIT(c) (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_XDIGIT)
+#define Py_ISALNUM(c)  (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_ALNUM)
+#define Py_ISSPACE(c)  (_Py_ctype_table[Py_CHARMASK(c)] & PY_CTF_SPACE)
+
+PyAPI_DATA(const unsigned char) _Py_ctype_tolower[256];
+PyAPI_DATA(const unsigned char) _Py_ctype_toupper[256];
+
+#define Py_TOLOWER(c) (_Py_ctype_tolower[Py_CHARMASK(c)])
+#define Py_TOUPPER(c) (_Py_ctype_toupper[Py_CHARMASK(c)])
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !PYCTYPE_H */
+#endif /* !Py_LIMITED_API */
diff --git a/marketing/include/pydebug.h b/marketing/include/pydebug.h
new file mode 100644
index 0000000000000000000000000000000000000000..78bcb118be46598f866aa62c05e66b87ca81a150
--- /dev/null
+++ b/marketing/include/pydebug.h
@@ -0,0 +1,38 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_PYDEBUG_H
+#define Py_PYDEBUG_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(int) Py_DebugFlag;
+PyAPI_DATA(int) Py_VerboseFlag;
+PyAPI_DATA(int) Py_QuietFlag;
+PyAPI_DATA(int) Py_InteractiveFlag;
+PyAPI_DATA(int) Py_InspectFlag;
+PyAPI_DATA(int) Py_OptimizeFlag;
+PyAPI_DATA(int) Py_NoSiteFlag;
+PyAPI_DATA(int) Py_BytesWarningFlag;
+PyAPI_DATA(int) Py_FrozenFlag;
+PyAPI_DATA(int) Py_IgnoreEnvironmentFlag;
+PyAPI_DATA(int) Py_DontWriteBytecodeFlag;
+PyAPI_DATA(int) Py_NoUserSiteDirectory;
+PyAPI_DATA(int) Py_UnbufferedStdioFlag;
+PyAPI_DATA(int) Py_HashRandomizationFlag;
+PyAPI_DATA(int) Py_IsolatedFlag;
+
+#ifdef MS_WINDOWS
+PyAPI_DATA(int) Py_LegacyWindowsFSEncodingFlag;
+PyAPI_DATA(int) Py_LegacyWindowsStdioFlag;
+#endif
+
+/* this is a wrapper around getenv() that pays attention to
+   Py_IgnoreEnvironmentFlag.  It should be used for getting variables like
+   PYTHONPATH and PYTHONHOME from the environment */
+#define Py_GETENV(s) (Py_IgnoreEnvironmentFlag ? NULL : getenv(s))
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PYDEBUG_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/pydtrace.d b/marketing/include/pydtrace.d
new file mode 100644
index 0000000000000000000000000000000000000000..5e6a626b01b82f669d685668d4c5ffa3ff474111
--- /dev/null
+++ b/marketing/include/pydtrace.d
@@ -0,0 +1,22 @@
+/* Python DTrace provider */
+
+provider python {
+    probe function__entry(const char *, const char *, int);
+    probe function__return(const char *, const char *, int);
+    probe instance__new__start(const char *, const char *);
+    probe instance__new__done(const char *, const char *);
+    probe instance__delete__start(const char *, const char *);
+    probe instance__delete__done(const char *, const char *);
+    probe line(const char *, const char *, int);
+    probe gc__start(int);
+    probe gc__done(long);
+    probe import__find__load__start(const char *);
+    probe import__find__load__done(const char *, int);
+    probe audit(const char *, void *);
+};
+
+#pragma D attributes Evolving/Evolving/Common provider python provider
+#pragma D attributes Evolving/Evolving/Common provider python module
+#pragma D attributes Evolving/Evolving/Common provider python function
+#pragma D attributes Evolving/Evolving/Common provider python name
+#pragma D attributes Evolving/Evolving/Common provider python args
diff --git a/marketing/include/pydtrace.h b/marketing/include/pydtrace.h
new file mode 100644
index 0000000000000000000000000000000000000000..75f8e7f70979c5266635dcf476605421b6a0fad9
--- /dev/null
+++ b/marketing/include/pydtrace.h
@@ -0,0 +1,59 @@
+/* Static DTrace probes interface */
+
+#ifndef Py_DTRACE_H
+#define Py_DTRACE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef WITH_DTRACE
+
+#include "pydtrace_probes.h"
+
+/* pydtrace_probes.h, on systems with DTrace, is auto-generated to include
+   `PyDTrace_{PROBE}` and `PyDTrace_{PROBE}_ENABLED()` macros for every probe
+   defined in pydtrace_provider.d.
+
+   Calling these functions must be guarded by a `PyDTrace_{PROBE}_ENABLED()`
+   check to minimize performance impact when probing is off. For example:
+
+       if (PyDTrace_FUNCTION_ENTRY_ENABLED())
+           PyDTrace_FUNCTION_ENTRY(f);
+*/
+
+#else
+
+/* Without DTrace, compile to nothing. */
+
+static inline void PyDTrace_LINE(const char *arg0, const char *arg1, int arg2) {}
+static inline void PyDTrace_FUNCTION_ENTRY(const char *arg0, const char *arg1, int arg2)  {}
+static inline void PyDTrace_FUNCTION_RETURN(const char *arg0, const char *arg1, int arg2) {}
+static inline void PyDTrace_GC_START(int arg0) {}
+static inline void PyDTrace_GC_DONE(Py_ssize_t arg0) {}
+static inline void PyDTrace_INSTANCE_NEW_START(int arg0) {}
+static inline void PyDTrace_INSTANCE_NEW_DONE(int arg0) {}
+static inline void PyDTrace_INSTANCE_DELETE_START(int arg0) {}
+static inline void PyDTrace_INSTANCE_DELETE_DONE(int arg0) {}
+static inline void PyDTrace_IMPORT_FIND_LOAD_START(const char *arg0) {}
+static inline void PyDTrace_IMPORT_FIND_LOAD_DONE(const char *arg0, int arg1) {}
+static inline void PyDTrace_AUDIT(const char *arg0, void *arg1) {}
+
+static inline int PyDTrace_LINE_ENABLED(void) { return 0; }
+static inline int PyDTrace_FUNCTION_ENTRY_ENABLED(void) { return 0; }
+static inline int PyDTrace_FUNCTION_RETURN_ENABLED(void) { return 0; }
+static inline int PyDTrace_GC_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_GC_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_NEW_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_NEW_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_DELETE_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_INSTANCE_DELETE_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_IMPORT_FIND_LOAD_START_ENABLED(void) { return 0; }
+static inline int PyDTrace_IMPORT_FIND_LOAD_DONE_ENABLED(void) { return 0; }
+static inline int PyDTrace_AUDIT_ENABLED(void) { return 0; }
+
+#endif /* !WITH_DTRACE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_DTRACE_H */
diff --git a/marketing/include/pyerrors.h b/marketing/include/pyerrors.h
new file mode 100644
index 0000000000000000000000000000000000000000..979a26ba68a0335b760756e08ba55bb311353ea6
--- /dev/null
+++ b/marketing/include/pyerrors.h
@@ -0,0 +1,326 @@
+#ifndef Py_ERRORS_H
+#define Py_ERRORS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include                // va_list
+
+/* Error handling definitions */
+
+PyAPI_FUNC(void) PyErr_SetNone(PyObject *);
+PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *);
+PyAPI_FUNC(void) PyErr_SetString(
+    PyObject *exception,
+    const char *string   /* decoded from utf-8 */
+    );
+PyAPI_FUNC(PyObject *) PyErr_Occurred(void);
+PyAPI_FUNC(void) PyErr_Clear(void);
+PyAPI_FUNC(void) PyErr_Fetch(PyObject **, PyObject **, PyObject **);
+PyAPI_FUNC(void) PyErr_Restore(PyObject *, PyObject *, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(void) PyErr_GetExcInfo(PyObject **, PyObject **, PyObject **);
+PyAPI_FUNC(void) PyErr_SetExcInfo(PyObject *, PyObject *, PyObject *);
+#endif
+
+/* Defined in Python/pylifecycle.c
+
+   The Py_FatalError() function is replaced with a macro which logs
+   automatically the name of the current function, unless the Py_LIMITED_API
+   macro is defined. */
+PyAPI_FUNC(void) _Py_NO_RETURN Py_FatalError(const char *message);
+
+#if defined(Py_DEBUG) || defined(Py_LIMITED_API)
+#define _PyErr_OCCURRED() PyErr_Occurred()
+#else
+#define _PyErr_OCCURRED() (PyThreadState_GET()->curexc_type)
+#endif
+
+/* Error testing and normalization */
+PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject *, PyObject *);
+PyAPI_FUNC(int) PyErr_ExceptionMatches(PyObject *);
+PyAPI_FUNC(void) PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);
+
+/* Traceback manipulation (PEP 3134) */
+PyAPI_FUNC(int) PyException_SetTraceback(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyException_GetTraceback(PyObject *);
+
+/* Cause manipulation (PEP 3134) */
+PyAPI_FUNC(PyObject *) PyException_GetCause(PyObject *);
+PyAPI_FUNC(void) PyException_SetCause(PyObject *, PyObject *);
+
+/* Context manipulation (PEP 3134) */
+PyAPI_FUNC(PyObject *) PyException_GetContext(PyObject *);
+PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *);
+
+/* */
+
+#define PyExceptionClass_Check(x)                                       \
+    (PyType_Check((x)) &&                                               \
+     PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
+
+#define PyExceptionInstance_Check(x)                    \
+    PyType_FastSubclass(Py_TYPE(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)
+
+PyAPI_FUNC(const char *) PyExceptionClass_Name(PyObject *);
+
+#define PyExceptionInstance_Class(x) ((PyObject*)Py_TYPE(x))
+
+
+/* Predefined exceptions */
+
+PyAPI_DATA(PyObject *) PyExc_BaseException;
+PyAPI_DATA(PyObject *) PyExc_Exception;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_DATA(PyObject *) PyExc_StopAsyncIteration;
+#endif
+PyAPI_DATA(PyObject *) PyExc_StopIteration;
+PyAPI_DATA(PyObject *) PyExc_GeneratorExit;
+PyAPI_DATA(PyObject *) PyExc_ArithmeticError;
+PyAPI_DATA(PyObject *) PyExc_LookupError;
+
+PyAPI_DATA(PyObject *) PyExc_AssertionError;
+PyAPI_DATA(PyObject *) PyExc_AttributeError;
+PyAPI_DATA(PyObject *) PyExc_BufferError;
+PyAPI_DATA(PyObject *) PyExc_EOFError;
+PyAPI_DATA(PyObject *) PyExc_FloatingPointError;
+PyAPI_DATA(PyObject *) PyExc_OSError;
+PyAPI_DATA(PyObject *) PyExc_ImportError;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+PyAPI_DATA(PyObject *) PyExc_ModuleNotFoundError;
+#endif
+PyAPI_DATA(PyObject *) PyExc_IndexError;
+PyAPI_DATA(PyObject *) PyExc_KeyError;
+PyAPI_DATA(PyObject *) PyExc_KeyboardInterrupt;
+PyAPI_DATA(PyObject *) PyExc_MemoryError;
+PyAPI_DATA(PyObject *) PyExc_NameError;
+PyAPI_DATA(PyObject *) PyExc_OverflowError;
+PyAPI_DATA(PyObject *) PyExc_RuntimeError;
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_DATA(PyObject *) PyExc_RecursionError;
+#endif
+PyAPI_DATA(PyObject *) PyExc_NotImplementedError;
+PyAPI_DATA(PyObject *) PyExc_SyntaxError;
+PyAPI_DATA(PyObject *) PyExc_IndentationError;
+PyAPI_DATA(PyObject *) PyExc_TabError;
+PyAPI_DATA(PyObject *) PyExc_ReferenceError;
+PyAPI_DATA(PyObject *) PyExc_SystemError;
+PyAPI_DATA(PyObject *) PyExc_SystemExit;
+PyAPI_DATA(PyObject *) PyExc_TypeError;
+PyAPI_DATA(PyObject *) PyExc_UnboundLocalError;
+PyAPI_DATA(PyObject *) PyExc_UnicodeError;
+PyAPI_DATA(PyObject *) PyExc_UnicodeEncodeError;
+PyAPI_DATA(PyObject *) PyExc_UnicodeDecodeError;
+PyAPI_DATA(PyObject *) PyExc_UnicodeTranslateError;
+PyAPI_DATA(PyObject *) PyExc_ValueError;
+PyAPI_DATA(PyObject *) PyExc_ZeroDivisionError;
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_DATA(PyObject *) PyExc_BlockingIOError;
+PyAPI_DATA(PyObject *) PyExc_BrokenPipeError;
+PyAPI_DATA(PyObject *) PyExc_ChildProcessError;
+PyAPI_DATA(PyObject *) PyExc_ConnectionError;
+PyAPI_DATA(PyObject *) PyExc_ConnectionAbortedError;
+PyAPI_DATA(PyObject *) PyExc_ConnectionRefusedError;
+PyAPI_DATA(PyObject *) PyExc_ConnectionResetError;
+PyAPI_DATA(PyObject *) PyExc_FileExistsError;
+PyAPI_DATA(PyObject *) PyExc_FileNotFoundError;
+PyAPI_DATA(PyObject *) PyExc_InterruptedError;
+PyAPI_DATA(PyObject *) PyExc_IsADirectoryError;
+PyAPI_DATA(PyObject *) PyExc_NotADirectoryError;
+PyAPI_DATA(PyObject *) PyExc_PermissionError;
+PyAPI_DATA(PyObject *) PyExc_ProcessLookupError;
+PyAPI_DATA(PyObject *) PyExc_TimeoutError;
+#endif
+
+
+/* Compatibility aliases */
+PyAPI_DATA(PyObject *) PyExc_EnvironmentError;
+PyAPI_DATA(PyObject *) PyExc_IOError;
+#ifdef MS_WINDOWS
+PyAPI_DATA(PyObject *) PyExc_WindowsError;
+#endif
+
+/* Predefined warning categories */
+PyAPI_DATA(PyObject *) PyExc_Warning;
+PyAPI_DATA(PyObject *) PyExc_UserWarning;
+PyAPI_DATA(PyObject *) PyExc_DeprecationWarning;
+PyAPI_DATA(PyObject *) PyExc_PendingDeprecationWarning;
+PyAPI_DATA(PyObject *) PyExc_SyntaxWarning;
+PyAPI_DATA(PyObject *) PyExc_RuntimeWarning;
+PyAPI_DATA(PyObject *) PyExc_FutureWarning;
+PyAPI_DATA(PyObject *) PyExc_ImportWarning;
+PyAPI_DATA(PyObject *) PyExc_UnicodeWarning;
+PyAPI_DATA(PyObject *) PyExc_BytesWarning;
+PyAPI_DATA(PyObject *) PyExc_ResourceWarning;
+
+
+/* Convenience functions */
+
+PyAPI_FUNC(int) PyErr_BadArgument(void);
+PyAPI_FUNC(PyObject *) PyErr_NoMemory(void);
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrno(PyObject *);
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObject(
+    PyObject *, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilenameObjects(
+    PyObject *, PyObject *, PyObject *);
+#endif
+PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename(
+    PyObject *exc,
+    const char *filename   /* decoded from the filesystem encoding */
+    );
+
+PyAPI_FUNC(PyObject *) PyErr_Format(
+    PyObject *exception,
+    const char *format,   /* ASCII-encoded string  */
+    ...
+    );
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_FUNC(PyObject *) PyErr_FormatV(
+    PyObject *exception,
+    const char *format,
+    va_list vargs);
+#endif
+
+#ifdef MS_WINDOWS
+PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename(
+    int ierr,
+    const char *filename        /* decoded from the filesystem encoding */
+    );
+PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int);
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject(
+    PyObject *,int, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObjects(
+    PyObject *,int, PyObject *, PyObject *);
+#endif
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename(
+    PyObject *exc,
+    int ierr,
+    const char *filename        /* decoded from the filesystem encoding */
+    );
+PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int);
+#endif /* MS_WINDOWS */
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+PyAPI_FUNC(PyObject *) PyErr_SetImportErrorSubclass(PyObject *, PyObject *,
+    PyObject *, PyObject *);
+#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject *) PyErr_SetImportError(PyObject *, PyObject *,
+    PyObject *);
+#endif
+
+/* Export the old function so that the existing API remains available: */
+PyAPI_FUNC(void) PyErr_BadInternalCall(void);
+PyAPI_FUNC(void) _PyErr_BadInternalCall(const char *filename, int lineno);
+/* Mask the old API with a call to the new API for code compiled under
+   Python 2.0: */
+#define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
+
+/* Function to create a new exception */
+PyAPI_FUNC(PyObject *) PyErr_NewException(
+    const char *name, PyObject *base, PyObject *dict);
+PyAPI_FUNC(PyObject *) PyErr_NewExceptionWithDoc(
+    const char *name, const char *doc, PyObject *base, PyObject *dict);
+PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *);
+
+
+/* In signalmodule.c */
+PyAPI_FUNC(int) PyErr_CheckSignals(void);
+PyAPI_FUNC(void) PyErr_SetInterrupt(void);
+
+/* Support for adding program text to SyntaxErrors */
+PyAPI_FUNC(void) PyErr_SyntaxLocation(
+    const char *filename,       /* decoded from the filesystem encoding */
+    int lineno);
+PyAPI_FUNC(void) PyErr_SyntaxLocationEx(
+    const char *filename,       /* decoded from the filesystem encoding */
+    int lineno,
+    int col_offset);
+PyAPI_FUNC(PyObject *) PyErr_ProgramText(
+    const char *filename,       /* decoded from the filesystem encoding */
+    int lineno);
+
+/* The following functions are used to create and modify unicode
+   exceptions from C */
+
+/* create a UnicodeDecodeError object */
+PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create(
+    const char *encoding,       /* UTF-8 encoded string */
+    const char *object,
+    Py_ssize_t length,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    const char *reason          /* UTF-8 encoded string */
+    );
+
+/* get the encoding attribute */
+PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetEncoding(PyObject *);
+
+/* get the object attribute */
+PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetObject(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetObject(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *);
+
+/* get the value of the start attribute (the int * may not be NULL)
+   return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);
+
+/* assign a new value to the start attribute
+   return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);
+
+/* get the value of the end attribute (the int *may not be NULL)
+ return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);
+PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);
+
+/* assign a new value to the end attribute
+   return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);
+
+/* get the value of the reason attribute */
+PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetReason(PyObject *);
+PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetReason(PyObject *);
+
+/* assign a new value to the reason attribute
+   return 0 on success, -1 on failure */
+PyAPI_FUNC(int) PyUnicodeEncodeError_SetReason(
+    PyObject *exc,
+    const char *reason          /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(int) PyUnicodeDecodeError_SetReason(
+    PyObject *exc,
+    const char *reason          /* UTF-8 encoded string */
+    );
+PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason(
+    PyObject *exc,
+    const char *reason          /* UTF-8 encoded string */
+    );
+
+PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char  *format, ...)
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 4)));
+PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char  *format, va_list va)
+                        Py_GCC_ATTRIBUTE((format(printf, 3, 0)));
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_ERRORS_H
+#  include  "cpython/pyerrors.h"
+#  undef Py_CPYTHON_ERRORS_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_ERRORS_H */
diff --git a/marketing/include/pyexpat.h b/marketing/include/pyexpat.h
new file mode 100644
index 0000000000000000000000000000000000000000..9824d099c3df7d08083ee6f9232dedcbe9d846a0
--- /dev/null
+++ b/marketing/include/pyexpat.h
@@ -0,0 +1,57 @@
+/* Stuff to export relevant 'expat' entry points from pyexpat to other
+ * parser modules, such as cElementTree. */
+
+/* note: you must import expat.h before importing this module! */
+
+#define PyExpat_CAPI_MAGIC  "pyexpat.expat_CAPI 1.1"
+#define PyExpat_CAPSULE_NAME "pyexpat.expat_CAPI"
+
+struct PyExpat_CAPI
+{
+    char* magic; /* set to PyExpat_CAPI_MAGIC */
+    int size; /* set to sizeof(struct PyExpat_CAPI) */
+    int MAJOR_VERSION;
+    int MINOR_VERSION;
+    int MICRO_VERSION;
+    /* pointers to selected expat functions.  add new functions at
+       the end, if needed */
+    const XML_LChar * (*ErrorString)(enum XML_Error code);
+    enum XML_Error (*GetErrorCode)(XML_Parser parser);
+    XML_Size (*GetErrorColumnNumber)(XML_Parser parser);
+    XML_Size (*GetErrorLineNumber)(XML_Parser parser);
+    enum XML_Status (*Parse)(
+        XML_Parser parser, const char *s, int len, int isFinal);
+    XML_Parser (*ParserCreate_MM)(
+        const XML_Char *encoding, const XML_Memory_Handling_Suite *memsuite,
+        const XML_Char *namespaceSeparator);
+    void (*ParserFree)(XML_Parser parser);
+    void (*SetCharacterDataHandler)(
+        XML_Parser parser, XML_CharacterDataHandler handler);
+    void (*SetCommentHandler)(
+        XML_Parser parser, XML_CommentHandler handler);
+    void (*SetDefaultHandlerExpand)(
+        XML_Parser parser, XML_DefaultHandler handler);
+    void (*SetElementHandler)(
+        XML_Parser parser, XML_StartElementHandler start,
+        XML_EndElementHandler end);
+    void (*SetNamespaceDeclHandler)(
+        XML_Parser parser, XML_StartNamespaceDeclHandler start,
+        XML_EndNamespaceDeclHandler end);
+    void (*SetProcessingInstructionHandler)(
+        XML_Parser parser, XML_ProcessingInstructionHandler handler);
+    void (*SetUnknownEncodingHandler)(
+        XML_Parser parser, XML_UnknownEncodingHandler handler,
+        void *encodingHandlerData);
+    void (*SetUserData)(XML_Parser parser, void *userData);
+    void (*SetStartDoctypeDeclHandler)(XML_Parser parser,
+                                       XML_StartDoctypeDeclHandler start);
+    enum XML_Status (*SetEncoding)(XML_Parser parser, const XML_Char *encoding);
+    int (*DefaultUnknownEncodingHandler)(
+        void *encodingHandlerData, const XML_Char *name, XML_Encoding *info);
+    /* might be NULL for expat < 2.1.0 */
+    int (*SetHashSalt)(XML_Parser parser, unsigned long hash_salt);
+    /* might be NULL for expat < 2.6.0 */
+    XML_Bool (*SetReparseDeferralEnabled)(XML_Parser parser, XML_Bool enabled);
+    /* always add new stuff to the end! */
+};
+
diff --git a/marketing/include/pyfpe.h b/marketing/include/pyfpe.h
new file mode 100644
index 0000000000000000000000000000000000000000..cc2def63aa5527f4ac192aa663a14353a88e1774
--- /dev/null
+++ b/marketing/include/pyfpe.h
@@ -0,0 +1,15 @@
+#ifndef Py_PYFPE_H
+#define Py_PYFPE_H
+/* Header excluded from the stable API */
+#ifndef Py_LIMITED_API
+
+/* These macros used to do something when Python was built with --with-fpectl,
+ * but support for that was dropped in 3.7. We continue to define them though,
+ * to avoid breaking API users.
+ */
+
+#define PyFPE_START_PROTECT(err_string, leave_stmt)
+#define PyFPE_END_PROTECT(v)
+
+#endif /* !defined(Py_LIMITED_API) */
+#endif /* !Py_PYFPE_H */
diff --git a/marketing/include/pyframe.h b/marketing/include/pyframe.h
new file mode 100644
index 0000000000000000000000000000000000000000..3816224201c7e44725d4aa0bf32d1b9da9256bc5
--- /dev/null
+++ b/marketing/include/pyframe.h
@@ -0,0 +1,22 @@
+/* Limited C API of PyFrame API
+ *
+ * Include "frameobject.h" to get the PyFrameObject structure.
+ */
+
+#ifndef Py_PYFRAME_H
+#define Py_PYFRAME_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _frame PyFrameObject;
+
+/* Return the line of code the frame is currently executing. */
+PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *);
+
+PyAPI_FUNC(PyCodeObject *) PyFrame_GetCode(PyFrameObject *frame);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PYFRAME_H */
diff --git a/marketing/include/pyhash.h b/marketing/include/pyhash.h
new file mode 100644
index 0000000000000000000000000000000000000000..4437b870332bdef3e9e5e7fa361f6d3b02f2207b
--- /dev/null
+++ b/marketing/include/pyhash.h
@@ -0,0 +1,147 @@
+#ifndef Py_HASH_H
+
+#define Py_HASH_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Helpers for hash functions */
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(Py_hash_t) _Py_HashDouble(double);
+PyAPI_FUNC(Py_hash_t) _Py_HashPointer(const void*);
+// Similar to _Py_HashPointer(), but don't replace -1 with -2
+PyAPI_FUNC(Py_hash_t) _Py_HashPointerRaw(const void*);
+PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void*, Py_ssize_t);
+#endif
+
+/* Prime multiplier used in string and various other hashes. */
+#define _PyHASH_MULTIPLIER 1000003UL  /* 0xf4243 */
+
+/* Parameters used for the numeric hash implementation.  See notes for
+   _Py_HashDouble in Python/pyhash.c.  Numeric hashes are based on
+   reduction modulo the prime 2**_PyHASH_BITS - 1. */
+
+#if SIZEOF_VOID_P >= 8
+#  define _PyHASH_BITS 61
+#else
+#  define _PyHASH_BITS 31
+#endif
+
+#define _PyHASH_MODULUS (((size_t)1 << _PyHASH_BITS) - 1)
+#define _PyHASH_INF 314159
+#define _PyHASH_NAN 0
+#define _PyHASH_IMAG _PyHASH_MULTIPLIER
+
+
+/* hash secret
+ *
+ * memory layout on 64 bit systems
+ *   cccccccc cccccccc cccccccc  uc -- unsigned char[24]
+ *   pppppppp ssssssss ........  fnv -- two Py_hash_t
+ *   k0k0k0k0 k1k1k1k1 ........  siphash -- two uint64_t
+ *   ........ ........ ssssssss  djbx33a -- 16 bytes padding + one Py_hash_t
+ *   ........ ........ eeeeeeee  pyexpat XML hash salt
+ *
+ * memory layout on 32 bit systems
+ *   cccccccc cccccccc cccccccc  uc
+ *   ppppssss ........ ........  fnv -- two Py_hash_t
+ *   k0k0k0k0 k1k1k1k1 ........  siphash -- two uint64_t (*)
+ *   ........ ........ ssss....  djbx33a -- 16 bytes padding + one Py_hash_t
+ *   ........ ........ eeee....  pyexpat XML hash salt
+ *
+ * (*) The siphash member may not be available on 32 bit platforms without
+ *     an unsigned int64 data type.
+ */
+#ifndef Py_LIMITED_API
+typedef union {
+    /* ensure 24 bytes */
+    unsigned char uc[24];
+    /* two Py_hash_t for FNV */
+    struct {
+        Py_hash_t prefix;
+        Py_hash_t suffix;
+    } fnv;
+    /* two uint64 for SipHash24 */
+    struct {
+        uint64_t k0;
+        uint64_t k1;
+    } siphash;
+    /* a different (!) Py_hash_t for small string optimization */
+    struct {
+        unsigned char padding[16];
+        Py_hash_t suffix;
+    } djbx33a;
+    struct {
+        unsigned char padding[16];
+        Py_hash_t hashsalt;
+    } expat;
+} _Py_HashSecret_t;
+PyAPI_DATA(_Py_HashSecret_t) _Py_HashSecret;
+#endif
+
+#ifdef Py_DEBUG
+PyAPI_DATA(int) _Py_HashSecret_Initialized;
+#endif
+
+
+/* hash function definition */
+#ifndef Py_LIMITED_API
+typedef struct {
+    Py_hash_t (*const hash)(const void *, Py_ssize_t);
+    const char *name;
+    const int hash_bits;
+    const int seed_bits;
+} PyHash_FuncDef;
+
+PyAPI_FUNC(PyHash_FuncDef*) PyHash_GetFuncDef(void);
+#endif
+
+
+/* cutoff for small string DJBX33A optimization in range [1, cutoff).
+ *
+ * About 50% of the strings in a typical Python application are smaller than
+ * 6 to 7 chars. However DJBX33A is vulnerable to hash collision attacks.
+ * NEVER use DJBX33A for long strings!
+ *
+ * A Py_HASH_CUTOFF of 0 disables small string optimization. 32 bit platforms
+ * should use a smaller cutoff because it is easier to create colliding
+ * strings. A cutoff of 7 on 64bit platforms and 5 on 32bit platforms should
+ * provide a decent safety margin.
+ */
+#ifndef Py_HASH_CUTOFF
+#  define Py_HASH_CUTOFF 0
+#elif (Py_HASH_CUTOFF > 7 || Py_HASH_CUTOFF < 0)
+#  error Py_HASH_CUTOFF must in range 0...7.
+#endif /* Py_HASH_CUTOFF */
+
+
+/* hash algorithm selection
+ *
+ * The values for Py_HASH_SIPHASH24 and Py_HASH_FNV are hard-coded in the
+ * configure script.
+ *
+ * - FNV is available on all platforms and architectures.
+ * - SIPHASH24 only works on platforms that don't require aligned memory for integers.
+ * - With EXTERNAL embedders can provide an alternative implementation with::
+ *
+ *     PyHash_FuncDef PyHash_Func = {...};
+ *
+ * XXX: Figure out __declspec() for extern PyHash_FuncDef.
+ */
+#define Py_HASH_EXTERNAL 0
+#define Py_HASH_SIPHASH24 1
+#define Py_HASH_FNV 2
+
+#ifndef Py_HASH_ALGORITHM
+#  ifndef HAVE_ALIGNED_REQUIRED
+#    define Py_HASH_ALGORITHM Py_HASH_SIPHASH24
+#  else
+#    define Py_HASH_ALGORITHM Py_HASH_FNV
+#  endif /* uint64_t && uint32_t && aligned */
+#endif /* Py_HASH_ALGORITHM */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_HASH_H */
diff --git a/marketing/include/pylifecycle.h b/marketing/include/pylifecycle.h
new file mode 100644
index 0000000000000000000000000000000000000000..783fcb455eb5289eeb1babca79b99ceb32cdd5bd
--- /dev/null
+++ b/marketing/include/pylifecycle.h
@@ -0,0 +1,77 @@
+
+/* Interfaces to configure, query, create & destroy the Python runtime */
+
+#ifndef Py_PYLIFECYCLE_H
+#define Py_PYLIFECYCLE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Initialization and finalization */
+PyAPI_FUNC(void) Py_Initialize(void);
+PyAPI_FUNC(void) Py_InitializeEx(int);
+PyAPI_FUNC(void) Py_Finalize(void);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+PyAPI_FUNC(int) Py_FinalizeEx(void);
+#endif
+PyAPI_FUNC(int) Py_IsInitialized(void);
+
+/* Subinterpreter support */
+PyAPI_FUNC(PyThreadState *) Py_NewInterpreter(void);
+PyAPI_FUNC(void) Py_EndInterpreter(PyThreadState *);
+
+
+/* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level
+ * exit functions.
+ */
+PyAPI_FUNC(int) Py_AtExit(void (*func)(void));
+
+PyAPI_FUNC(void) _Py_NO_RETURN Py_Exit(int);
+
+/* Bootstrap __main__ (defined in Modules/main.c) */
+PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv);
+
+PyAPI_FUNC(int) Py_FrozenMain(int argc, char **argv);
+
+PyAPI_FUNC(int) Py_BytesMain(int argc, char **argv);
+
+/* In pathconfig.c */
+PyAPI_FUNC(void) Py_SetProgramName(const wchar_t *);
+PyAPI_FUNC(wchar_t *) Py_GetProgramName(void);
+
+PyAPI_FUNC(void) Py_SetPythonHome(const wchar_t *);
+PyAPI_FUNC(wchar_t *) Py_GetPythonHome(void);
+
+PyAPI_FUNC(wchar_t *) Py_GetProgramFullPath(void);
+
+PyAPI_FUNC(wchar_t *) Py_GetPrefix(void);
+PyAPI_FUNC(wchar_t *) Py_GetExecPrefix(void);
+PyAPI_FUNC(wchar_t *) Py_GetPath(void);
+PyAPI_FUNC(void)      Py_SetPath(const wchar_t *);
+#ifdef MS_WINDOWS
+int _Py_CheckPython3(void);
+#endif
+
+/* In their own files */
+PyAPI_FUNC(const char *) Py_GetVersion(void);
+PyAPI_FUNC(const char *) Py_GetPlatform(void);
+PyAPI_FUNC(const char *) Py_GetCopyright(void);
+PyAPI_FUNC(const char *) Py_GetCompiler(void);
+PyAPI_FUNC(const char *) Py_GetBuildInfo(void);
+
+/* Signals */
+typedef void (*PyOS_sighandler_t)(int);
+PyAPI_FUNC(PyOS_sighandler_t) PyOS_getsig(int);
+PyAPI_FUNC(PyOS_sighandler_t) PyOS_setsig(int, PyOS_sighandler_t);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_PYLIFECYCLE_H
+#  include  "cpython/pylifecycle.h"
+#  undef Py_CPYTHON_PYLIFECYCLE_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PYLIFECYCLE_H */
diff --git a/marketing/include/pymacconfig.h b/marketing/include/pymacconfig.h
new file mode 100644
index 0000000000000000000000000000000000000000..9dde11bd58e2171be78ecf4d3423b1b231ac17ec
--- /dev/null
+++ b/marketing/include/pymacconfig.h
@@ -0,0 +1,102 @@
+#ifndef PYMACCONFIG_H
+#define PYMACCONFIG_H
+     /*
+      * This file moves some of the autoconf magic to compile-time
+      * when building on MacOSX. This is needed for building 4-way
+      * universal binaries and for 64-bit universal binaries because
+      * the values redefined below aren't configure-time constant but
+      * only compile-time constant in these scenarios.
+      */
+
+#if defined(__APPLE__)
+
+# undef SIZEOF_LONG
+# undef SIZEOF_PTHREAD_T
+# undef SIZEOF_SIZE_T
+# undef SIZEOF_TIME_T
+# undef SIZEOF_VOID_P
+# undef SIZEOF__BOOL
+# undef SIZEOF_UINTPTR_T
+# undef SIZEOF_PTHREAD_T
+# undef WORDS_BIGENDIAN
+# undef DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754
+# undef DOUBLE_IS_BIG_ENDIAN_IEEE754
+# undef DOUBLE_IS_LITTLE_ENDIAN_IEEE754
+# undef HAVE_GCC_ASM_FOR_X87
+
+#    undef VA_LIST_IS_ARRAY
+#    if defined(__LP64__) && defined(__x86_64__)
+#        define VA_LIST_IS_ARRAY 1
+#    endif
+
+#    undef HAVE_LARGEFILE_SUPPORT
+#    ifndef __LP64__
+#         define HAVE_LARGEFILE_SUPPORT 1
+#    endif
+
+#    undef SIZEOF_LONG
+#    ifdef __LP64__
+#        define SIZEOF__BOOL            1
+#        define SIZEOF__BOOL            1
+#        define SIZEOF_LONG             8
+#        define SIZEOF_PTHREAD_T        8
+#        define SIZEOF_SIZE_T           8
+#        define SIZEOF_TIME_T           8
+#        define SIZEOF_VOID_P           8
+#        define SIZEOF_UINTPTR_T        8
+#        define SIZEOF_PTHREAD_T        8
+#    else
+#        ifdef __ppc__
+#           define SIZEOF__BOOL         4
+#        else
+#           define SIZEOF__BOOL         1
+#        endif
+#        define SIZEOF_LONG             4
+#        define SIZEOF_PTHREAD_T        4
+#        define SIZEOF_SIZE_T           4
+#        define SIZEOF_TIME_T           4
+#        define SIZEOF_VOID_P           4
+#        define SIZEOF_UINTPTR_T        4
+#        define SIZEOF_PTHREAD_T        4
+#    endif
+
+#    if defined(__LP64__)
+     /* MacOSX 10.4 (the first release to support 64-bit code
+      * at all) only supports 64-bit in the UNIX layer.
+      * Therefore suppress the toolbox-glue in 64-bit mode.
+      */
+
+    /* In 64-bit mode setpgrp always has no arguments, in 32-bit
+     * mode that depends on the compilation environment
+     */
+#       undef SETPGRP_HAVE_ARG
+
+#    endif
+
+#ifdef __BIG_ENDIAN__
+#define WORDS_BIGENDIAN 1
+#define DOUBLE_IS_BIG_ENDIAN_IEEE754
+#else
+#define DOUBLE_IS_LITTLE_ENDIAN_IEEE754
+#endif /* __BIG_ENDIAN */
+
+#ifdef __i386__
+# define HAVE_GCC_ASM_FOR_X87
+#endif
+
+    /*
+     * The definition in pyconfig.h is only valid on the OS release
+     * where configure ran on and not necessarily for all systems where
+     * the executable can be used on.
+     *
+     * Specifically: OSX 10.4 has limited supported for '%zd', while
+     * 10.5 has full support for '%zd'. A binary built on 10.5 won't
+     * work properly on 10.4 unless we suppress the definition
+     * of PY_FORMAT_SIZE_T
+     */
+#undef  PY_FORMAT_SIZE_T
+
+
+#endif /* defined(_APPLE__) */
+
+#endif /* PYMACCONFIG_H */
diff --git a/marketing/include/pymacro.h b/marketing/include/pymacro.h
new file mode 100644
index 0000000000000000000000000000000000000000..202b936d964f00dec2f7cb8a3fc993f1bd6cfc85
--- /dev/null
+++ b/marketing/include/pymacro.h
@@ -0,0 +1,132 @@
+#ifndef Py_PYMACRO_H
+#define Py_PYMACRO_H
+
+/* Minimum value between x and y */
+#define Py_MIN(x, y) (((x) > (y)) ? (y) : (x))
+
+/* Maximum value between x and y */
+#define Py_MAX(x, y) (((x) > (y)) ? (x) : (y))
+
+/* Absolute value of the number x */
+#define Py_ABS(x) ((x) < 0 ? -(x) : (x))
+
+#define _Py_XSTRINGIFY(x) #x
+
+/* Convert the argument to a string. For example, Py_STRINGIFY(123) is replaced
+   with "123" by the preprocessor. Defines are also replaced by their value.
+   For example Py_STRINGIFY(__LINE__) is replaced by the line number, not
+   by "__LINE__". */
+#define Py_STRINGIFY(x) _Py_XSTRINGIFY(x)
+
+/* Get the size of a structure member in bytes */
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+
+/* Argument must be a char or an int in [-128, 127] or [0, 255]. */
+#define Py_CHARMASK(c) ((unsigned char)((c) & 0xff))
+
+/* Assert a build-time dependency, as an expression.
+
+   Your compile will fail if the condition isn't true, or can't be evaluated
+   by the compiler. This can be used in an expression: its value is 0.
+
+   Example:
+
+   #define foo_to_char(foo)  \
+       ((char *)(foo)        \
+        + Py_BUILD_ASSERT_EXPR(offsetof(struct foo, string) == 0))
+
+   Written by Rusty Russell, public domain, http://ccodearchive.net/ */
+#define Py_BUILD_ASSERT_EXPR(cond) \
+    (sizeof(char [1 - 2*!(cond)]) - 1)
+
+#define Py_BUILD_ASSERT(cond)  do {         \
+        (void)Py_BUILD_ASSERT_EXPR(cond);   \
+    } while(0)
+
+/* Get the number of elements in a visible array
+
+   This does not work on pointers, or arrays declared as [], or function
+   parameters. With correct compiler support, such usage will cause a build
+   error (see Py_BUILD_ASSERT_EXPR).
+
+   Written by Rusty Russell, public domain, http://ccodearchive.net/
+
+   Requires at GCC 3.1+ */
+#if (defined(__GNUC__) && !defined(__STRICT_ANSI__) && \
+    (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ >= 4)))
+/* Two gcc extensions.
+   &a[0] degrades to a pointer: a different type from an array */
+#define Py_ARRAY_LENGTH(array) \
+    (sizeof(array) / sizeof((array)[0]) \
+     + Py_BUILD_ASSERT_EXPR(!__builtin_types_compatible_p(typeof(array), \
+                                                          typeof(&(array)[0]))))
+#else
+#define Py_ARRAY_LENGTH(array) \
+    (sizeof(array) / sizeof((array)[0]))
+#endif
+
+
+/* Define macros for inline documentation. */
+#define PyDoc_VAR(name) static const char name[]
+#define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)
+#ifdef WITH_DOC_STRINGS
+#define PyDoc_STR(str) str
+#else
+#define PyDoc_STR(str) ""
+#endif
+
+/* Below "a" is a power of 2. */
+/* Round down size "n" to be a multiple of "a". */
+#define _Py_SIZE_ROUND_DOWN(n, a) ((size_t)(n) & ~(size_t)((a) - 1))
+/* Round up size "n" to be a multiple of "a". */
+#define _Py_SIZE_ROUND_UP(n, a) (((size_t)(n) + \
+        (size_t)((a) - 1)) & ~(size_t)((a) - 1))
+/* Round pointer "p" down to the closest "a"-aligned address <= "p". */
+#define _Py_ALIGN_DOWN(p, a) ((void *)((uintptr_t)(p) & ~(uintptr_t)((a) - 1)))
+/* Round pointer "p" up to the closest "a"-aligned address >= "p". */
+#define _Py_ALIGN_UP(p, a) ((void *)(((uintptr_t)(p) + \
+        (uintptr_t)((a) - 1)) & ~(uintptr_t)((a) - 1)))
+/* Check if pointer "p" is aligned to "a"-bytes boundary. */
+#define _Py_IS_ALIGNED(p, a) (!((uintptr_t)(p) & (uintptr_t)((a) - 1)))
+
+/* Use this for unused arguments in a function definition to silence compiler
+ * warnings. Example:
+ *
+ * int func(int a, int Py_UNUSED(b)) { return a; }
+ */
+#if defined(__GNUC__) || defined(__clang__)
+#  define Py_UNUSED(name) _unused_ ## name __attribute__((unused))
+#else
+#  define Py_UNUSED(name) _unused_ ## name
+#endif
+
+#if defined(RANDALL_WAS_HERE)
+#  define Py_UNREACHABLE() \
+    Py_FatalError( \
+        "If you're seeing this, the code is in what I thought was\n" \
+        "an unreachable state.\n\n" \
+        "I could give you advice for what to do, but honestly, why\n" \
+        "should you trust me?  I clearly screwed this up.  I'm writing\n" \
+        "a message that should never appear, yet I know it will\n" \
+        "probably appear someday.\n\n" \
+        "On a deep level, I know I'm not up to this task.\n" \
+        "I'm so sorry.\n" \
+        "https://xkcd.com/2200")
+#elif defined(Py_DEBUG)
+#  define Py_UNREACHABLE() \
+    Py_FatalError( \
+        "We've reached an unreachable state. Anything is possible.\n" \
+        "The limits were in our heads all along. Follow your dreams.\n" \
+        "https://xkcd.com/2200")
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#  define Py_UNREACHABLE() __builtin_unreachable()
+#elif defined(__clang__) || defined(__INTEL_COMPILER)
+#  define Py_UNREACHABLE() __builtin_unreachable()
+#elif defined(_MSC_VER)
+#  define Py_UNREACHABLE() __assume(0)
+#else
+#  define Py_UNREACHABLE() \
+    Py_FatalError("Unreachable C code path reached")
+#endif
+
+#endif /* Py_PYMACRO_H */
diff --git a/marketing/include/pymath.h b/marketing/include/pymath.h
new file mode 100644
index 0000000000000000000000000000000000000000..63ca972784e3116f087701aa2af65c34564ed8b0
--- /dev/null
+++ b/marketing/include/pymath.h
@@ -0,0 +1,238 @@
+#ifndef Py_PYMATH_H
+#define Py_PYMATH_H
+
+#include "pyconfig.h" /* include for defines */
+
+/**************************************************************************
+Symbols and macros to supply platform-independent interfaces to mathematical
+functions and constants
+**************************************************************************/
+
+/* Python provides implementations for copysign, round and hypot in
+ * Python/pymath.c just in case your math library doesn't provide the
+ * functions.
+ *
+ *Note: PC/pyconfig.h defines copysign as _copysign
+ */
+#ifndef HAVE_COPYSIGN
+extern double copysign(double, double);
+#endif
+
+#ifndef HAVE_ROUND
+extern double round(double);
+#endif
+
+#ifndef HAVE_HYPOT
+extern double hypot(double, double);
+#endif
+
+/* extra declarations */
+#ifndef _MSC_VER
+#ifndef __STDC__
+extern double fmod (double, double);
+extern double frexp (double, int *);
+extern double ldexp (double, int);
+extern double modf (double, double *);
+extern double pow(double, double);
+#endif /* __STDC__ */
+#endif /* _MSC_VER */
+
+/* High precision definition of pi and e (Euler)
+ * The values are taken from libc6's math.h.
+ */
+#ifndef Py_MATH_PIl
+#define Py_MATH_PIl 3.1415926535897932384626433832795029L
+#endif
+#ifndef Py_MATH_PI
+#define Py_MATH_PI 3.14159265358979323846
+#endif
+
+#ifndef Py_MATH_El
+#define Py_MATH_El 2.7182818284590452353602874713526625L
+#endif
+
+#ifndef Py_MATH_E
+#define Py_MATH_E 2.7182818284590452354
+#endif
+
+/* Tau (2pi) to 40 digits, taken from tauday.com/tau-digits. */
+#ifndef Py_MATH_TAU
+#define Py_MATH_TAU 6.2831853071795864769252867665590057683943L
+#endif
+
+
+/* On x86, Py_FORCE_DOUBLE forces a floating-point number out of an x87 FPU
+   register and into a 64-bit memory location, rounding from extended
+   precision to double precision in the process.  On other platforms it does
+   nothing. */
+
+/* we take double rounding as evidence of x87 usage */
+#ifndef Py_LIMITED_API
+#ifndef Py_FORCE_DOUBLE
+#  ifdef X87_DOUBLE_ROUNDING
+PyAPI_FUNC(double) _Py_force_double(double);
+#    define Py_FORCE_DOUBLE(X) (_Py_force_double(X))
+#  else
+#    define Py_FORCE_DOUBLE(X) (X)
+#  endif
+#endif
+#endif
+
+#ifndef Py_LIMITED_API
+#ifdef HAVE_GCC_ASM_FOR_X87
+PyAPI_FUNC(unsigned short) _Py_get_387controlword(void);
+PyAPI_FUNC(void) _Py_set_387controlword(unsigned short);
+#endif
+#endif
+
+/* Py_IS_NAN(X)
+ * Return 1 if float or double arg is a NaN, else 0.
+ * Caution:
+ *     X is evaluated more than once.
+ *     This may not work on all platforms.  Each platform has *some*
+ *     way to spell this, though -- override in pyconfig.h if you have
+ *     a platform where it doesn't work.
+ * Note: PC/pyconfig.h defines Py_IS_NAN as _isnan
+ */
+#ifndef Py_IS_NAN
+#if defined HAVE_DECL_ISNAN && HAVE_DECL_ISNAN == 1
+#define Py_IS_NAN(X) isnan(X)
+#else
+#define Py_IS_NAN(X) ((X) != (X))
+#endif
+#endif
+
+/* Py_IS_INFINITY(X)
+ * Return 1 if float or double arg is an infinity, else 0.
+ * Caution:
+ *    X is evaluated more than once.
+ *    This implementation may set the underflow flag if |X| is very small;
+ *    it really can't be implemented correctly (& easily) before C99.
+ *    Override in pyconfig.h if you have a better spelling on your platform.
+ *  Py_FORCE_DOUBLE is used to avoid getting false negatives from a
+ *    non-infinite value v sitting in an 80-bit x87 register such that
+ *    v becomes infinite when spilled from the register to 64-bit memory.
+ * Note: PC/pyconfig.h defines Py_IS_INFINITY as _isinf
+ */
+#ifndef Py_IS_INFINITY
+#  if defined HAVE_DECL_ISINF && HAVE_DECL_ISINF == 1
+#    define Py_IS_INFINITY(X) isinf(X)
+#  else
+#    define Py_IS_INFINITY(X) ((X) &&                                   \
+                               (Py_FORCE_DOUBLE(X)*0.5 == Py_FORCE_DOUBLE(X)))
+#  endif
+#endif
+
+/* Py_IS_FINITE(X)
+ * Return 1 if float or double arg is neither infinite nor NAN, else 0.
+ * Some compilers (e.g. VisualStudio) have intrinsics for this, so a special
+ * macro for this particular test is useful
+ * Note: PC/pyconfig.h defines Py_IS_FINITE as _finite
+ */
+#ifndef Py_IS_FINITE
+#if defined HAVE_DECL_ISFINITE && HAVE_DECL_ISFINITE == 1
+#define Py_IS_FINITE(X) isfinite(X)
+#elif defined HAVE_FINITE
+#define Py_IS_FINITE(X) finite(X)
+#else
+#define Py_IS_FINITE(X) (!Py_IS_INFINITY(X) && !Py_IS_NAN(X))
+#endif
+#endif
+
+/* HUGE_VAL is supposed to expand to a positive double infinity.  Python
+ * uses Py_HUGE_VAL instead because some platforms are broken in this
+ * respect.  We used to embed code in pyport.h to try to worm around that,
+ * but different platforms are broken in conflicting ways.  If you're on
+ * a platform where HUGE_VAL is defined incorrectly, fiddle your Python
+ * config to #define Py_HUGE_VAL to something that works on your platform.
+ */
+#ifndef Py_HUGE_VAL
+#define Py_HUGE_VAL HUGE_VAL
+#endif
+
+/* Py_NAN
+ * A value that evaluates to a NaN. On IEEE 754 platforms INF*0 or
+ * INF/INF works. Define Py_NO_NAN in pyconfig.h if your platform
+ * doesn't support NaNs.
+ */
+#if !defined(Py_NAN) && !defined(Py_NO_NAN)
+#if !defined(__INTEL_COMPILER)
+    #define Py_NAN (Py_HUGE_VAL * 0.)
+#else /* __INTEL_COMPILER */
+    #if defined(ICC_NAN_STRICT)
+        #pragma float_control(push)
+        #pragma float_control(precise, on)
+        #pragma float_control(except,  on)
+        #if defined(_MSC_VER)
+            __declspec(noinline)
+        #else /* Linux */
+            __attribute__((noinline))
+        #endif /* _MSC_VER */
+        static double __icc_nan()
+        {
+            return sqrt(-1.0);
+        }
+        #pragma float_control (pop)
+        #define Py_NAN __icc_nan()
+    #else /* ICC_NAN_RELAXED as default for Intel Compiler */
+        static const union { unsigned char buf[8]; double __icc_nan; } __nan_store = {0,0,0,0,0,0,0xf8,0x7f};
+        #define Py_NAN (__nan_store.__icc_nan)
+    #endif /* ICC_NAN_STRICT */
+#endif /* __INTEL_COMPILER */
+#endif
+
+/* Py_OVERFLOWED(X)
+ * Return 1 iff a libm function overflowed.  Set errno to 0 before calling
+ * a libm function, and invoke this macro after, passing the function
+ * result.
+ * Caution:
+ *    This isn't reliable.  C99 no longer requires libm to set errno under
+ *        any exceptional condition, but does require +- HUGE_VAL return
+ *        values on overflow.  A 754 box *probably* maps HUGE_VAL to a
+ *        double infinity, and we're cool if that's so, unless the input
+ *        was an infinity and an infinity is the expected result.  A C89
+ *        system sets errno to ERANGE, so we check for that too.  We're
+ *        out of luck if a C99 754 box doesn't map HUGE_VAL to +Inf, or
+ *        if the returned result is a NaN, or if a C89 box returns HUGE_VAL
+ *        in non-overflow cases.
+ *    X is evaluated more than once.
+ * Some platforms have better way to spell this, so expect some #ifdef'ery.
+ *
+ * OpenBSD uses 'isinf()' because a compiler bug on that platform causes
+ * the longer macro version to be mis-compiled. This isn't optimal, and
+ * should be removed once a newer compiler is available on that platform.
+ * The system that had the failure was running OpenBSD 3.2 on Intel, with
+ * gcc 2.95.3.
+ *
+ * According to Tim's checkin, the FreeBSD systems use isinf() to work
+ * around a FPE bug on that platform.
+ */
+#if defined(__FreeBSD__) || defined(__OpenBSD__)
+#define Py_OVERFLOWED(X) isinf(X)
+#else
+#define Py_OVERFLOWED(X) ((X) != 0.0 && (errno == ERANGE ||    \
+                                         (X) == Py_HUGE_VAL || \
+                                         (X) == -Py_HUGE_VAL))
+#endif
+
+/* Return whether integral type *type* is signed or not. */
+#define _Py_IntegralTypeSigned(type) ((type)(-1) < 0)
+/* Return the maximum value of integral type *type*. */
+#define _Py_IntegralTypeMax(type) ((_Py_IntegralTypeSigned(type)) ? (((((type)1 << (sizeof(type)*CHAR_BIT - 2)) - 1) << 1) + 1) : ~(type)0)
+/* Return the minimum value of integral type *type*. */
+#define _Py_IntegralTypeMin(type) ((_Py_IntegralTypeSigned(type)) ? -_Py_IntegralTypeMax(type) - 1 : 0)
+/* Check whether *v* is in the range of integral type *type*. This is most
+ * useful if *v* is floating-point, since demoting a floating-point *v* to an
+ * integral type that cannot represent *v*'s integral part is undefined
+ * behavior. */
+#define _Py_InIntegralTypeRange(type, v) (_Py_IntegralTypeMin(type) <= v && v <= _Py_IntegralTypeMax(type))
+
+/* Return the smallest integer k such that n < 2**k, or 0 if n == 0.
+ * Equivalent to floor(log2(x))+1.  Also equivalent to: bitwidth_of_type -
+ * count_leading_zero_bits(x)
+ */
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(unsigned int) _Py_bit_length(unsigned long d);
+#endif
+
+#endif /* Py_PYMATH_H */
diff --git a/marketing/include/pymem.h b/marketing/include/pymem.h
new file mode 100644
index 0000000000000000000000000000000000000000..607feb9484f24f14d562f1a32fbae9ad8b7fe16d
--- /dev/null
+++ b/marketing/include/pymem.h
@@ -0,0 +1,115 @@
+/* The PyMem_ family:  low-level memory allocation interfaces.
+   See objimpl.h for the PyObject_ memory family.
+*/
+
+#ifndef Py_PYMEM_H
+#define Py_PYMEM_H
+
+#include "pyport.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BEWARE:
+
+   Each interface exports both functions and macros.  Extension modules should
+   use the functions, to ensure binary compatibility across Python versions.
+   Because the Python implementation is free to change internal details, and
+   the macros may (or may not) expose details for speed, if you do use the
+   macros you must recompile your extensions with each Python release.
+
+   Never mix calls to PyMem_ with calls to the platform malloc/realloc/
+   calloc/free.  For example, on Windows different DLLs may end up using
+   different heaps, and if you use PyMem_Malloc you'll get the memory from the
+   heap used by the Python DLL; it could be a disaster if you free()'ed that
+   directly in your own extension.  Using PyMem_Free instead ensures Python
+   can return the memory to the proper heap.  As another example, in
+   PYMALLOC_DEBUG mode, Python wraps all calls to all PyMem_ and PyObject_
+   memory functions in special debugging wrappers that add additional
+   debugging info to dynamic memory blocks.  The system routines have no idea
+   what to do with that stuff, and the Python wrappers have no idea what to do
+   with raw blocks obtained directly by the system routines then.
+
+   The GIL must be held when using these APIs.
+*/
+
+/*
+ * Raw memory interface
+ * ====================
+ */
+
+/* Functions
+
+   Functions supplying platform-independent semantics for malloc/realloc/
+   free.  These functions make sure that allocating 0 bytes returns a distinct
+   non-NULL pointer (whenever possible -- if we're flat out of memory, NULL
+   may be returned), even if the platform malloc and realloc don't.
+   Returned pointers must be checked for NULL explicitly.  No action is
+   performed on failure (no exception is set, no warning is printed, etc).
+*/
+
+PyAPI_FUNC(void *) PyMem_Malloc(size_t size);
+PyAPI_FUNC(void *) PyMem_Realloc(void *ptr, size_t new_size);
+PyAPI_FUNC(void) PyMem_Free(void *ptr);
+
+/* Macros. */
+
+/* PyMem_MALLOC(0) means malloc(1). Some systems would return NULL
+   for malloc(0), which would be treated as an error. Some platforms
+   would return a pointer with no memory behind it, which would break
+   pymalloc. To solve these problems, allocate an extra byte. */
+/* Returns NULL to indicate error if a negative size or size larger than
+   Py_ssize_t can represent is supplied.  Helps prevents security holes. */
+#define PyMem_MALLOC(n)         PyMem_Malloc(n)
+#define PyMem_REALLOC(p, n)     PyMem_Realloc(p, n)
+#define PyMem_FREE(p)           PyMem_Free(p)
+
+/*
+ * Type-oriented memory interface
+ * ==============================
+ *
+ * Allocate memory for n objects of the given type.  Returns a new pointer
+ * or NULL if the request was too large or memory allocation failed.  Use
+ * these macros rather than doing the multiplication yourself so that proper
+ * overflow checking is always done.
+ */
+
+#define PyMem_New(type, n) \
+  ( ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL :      \
+        ( (type *) PyMem_Malloc((n) * sizeof(type)) ) )
+#define PyMem_NEW(type, n) \
+  ( ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL :      \
+        ( (type *) PyMem_MALLOC((n) * sizeof(type)) ) )
+
+/*
+ * The value of (p) is always clobbered by this macro regardless of success.
+ * The caller MUST check if (p) is NULL afterwards and deal with the memory
+ * error if so.  This means the original value of (p) MUST be saved for the
+ * caller's memory error handler to not lose track of it.
+ */
+#define PyMem_Resize(p, type, n) \
+  ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL :        \
+        (type *) PyMem_Realloc((p), (n) * sizeof(type)) )
+#define PyMem_RESIZE(p, type, n) \
+  ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL :        \
+        (type *) PyMem_REALLOC((p), (n) * sizeof(type)) )
+
+/* PyMem{Del,DEL} are left over from ancient days, and shouldn't be used
+ * anymore.  They're just confusing aliases for PyMem_{Free,FREE} now.
+ */
+#define PyMem_Del               PyMem_Free
+#define PyMem_DEL               PyMem_FREE
+
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_PYMEM_H
+#  include  "cpython/pymem.h"
+#  undef Py_CPYTHON_PYMEM_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_PYMEM_H */
diff --git a/marketing/include/pyport.h b/marketing/include/pyport.h
new file mode 100644
index 0000000000000000000000000000000000000000..4bd4eb4751b952e34f88844f38248993acee79dd
--- /dev/null
+++ b/marketing/include/pyport.h
@@ -0,0 +1,878 @@
+#ifndef Py_PYPORT_H
+#define Py_PYPORT_H
+
+#include "pyconfig.h" /* include for defines */
+
+#include 
+
+
+/* Defines to build Python and its standard library:
+ *
+ * - Py_BUILD_CORE: Build Python core. Give access to Python internals, but
+ *   should not be used by third-party modules.
+ * - Py_BUILD_CORE_BUILTIN: Build a Python stdlib module as a built-in module.
+ * - Py_BUILD_CORE_MODULE: Build a Python stdlib module as a dynamic library.
+ *
+ * Py_BUILD_CORE_BUILTIN and Py_BUILD_CORE_MODULE imply Py_BUILD_CORE.
+ *
+ * On Windows, Py_BUILD_CORE_MODULE exports "PyInit_xxx" symbol, whereas
+ * Py_BUILD_CORE_BUILTIN does not.
+ */
+#if defined(Py_BUILD_CORE_BUILTIN) && !defined(Py_BUILD_CORE)
+#  define Py_BUILD_CORE
+#endif
+#if defined(Py_BUILD_CORE_MODULE) && !defined(Py_BUILD_CORE)
+#  define Py_BUILD_CORE
+#endif
+
+
+/**************************************************************************
+Symbols and macros to supply platform-independent interfaces to basic
+C language & library operations whose spellings vary across platforms.
+
+Please try to make documentation here as clear as possible:  by definition,
+the stuff here is trying to illuminate C's darkest corners.
+
+Config #defines referenced here:
+
+SIGNED_RIGHT_SHIFT_ZERO_FILLS
+Meaning:  To be defined iff i>>j does not extend the sign bit when i is a
+          signed integral type and i < 0.
+Used in:  Py_ARITHMETIC_RIGHT_SHIFT
+
+Py_DEBUG
+Meaning:  Extra checks compiled in for debug mode.
+Used in:  Py_SAFE_DOWNCAST
+
+**************************************************************************/
+
+/* typedefs for some C9X-defined synonyms for integral types.
+ *
+ * The names in Python are exactly the same as the C9X names, except with a
+ * Py_ prefix.  Until C9X is universally implemented, this is the only way
+ * to ensure that Python gets reliable names that don't conflict with names
+ * in non-Python code that are playing their own tricks to define the C9X
+ * names.
+ *
+ * NOTE: don't go nuts here!  Python has no use for *most* of the C9X
+ * integral synonyms.  Only define the ones we actually need.
+ */
+
+/* long long is required. Ensure HAVE_LONG_LONG is defined for compatibility. */
+#ifndef HAVE_LONG_LONG
+#define HAVE_LONG_LONG 1
+#endif
+#ifndef PY_LONG_LONG
+#define PY_LONG_LONG long long
+/* If LLONG_MAX is defined in limits.h, use that. */
+#define PY_LLONG_MIN LLONG_MIN
+#define PY_LLONG_MAX LLONG_MAX
+#define PY_ULLONG_MAX ULLONG_MAX
+#endif
+
+#define PY_UINT32_T uint32_t
+#define PY_UINT64_T uint64_t
+
+/* Signed variants of the above */
+#define PY_INT32_T int32_t
+#define PY_INT64_T int64_t
+
+/* If PYLONG_BITS_IN_DIGIT is not defined then we'll use 30-bit digits if all
+   the necessary integer types are available, and we're on a 64-bit platform
+   (as determined by SIZEOF_VOID_P); otherwise we use 15-bit digits. */
+
+#ifndef PYLONG_BITS_IN_DIGIT
+#if SIZEOF_VOID_P >= 8
+#define PYLONG_BITS_IN_DIGIT 30
+#else
+#define PYLONG_BITS_IN_DIGIT 15
+#endif
+#endif
+
+/* uintptr_t is the C9X name for an unsigned integral type such that a
+ * legitimate void* can be cast to uintptr_t and then back to void* again
+ * without loss of information.  Similarly for intptr_t, wrt a signed
+ * integral type.
+ */
+typedef uintptr_t       Py_uintptr_t;
+typedef intptr_t        Py_intptr_t;
+
+/* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) ==
+ * sizeof(size_t).  C99 doesn't define such a thing directly (size_t is an
+ * unsigned integral type).  See PEP 353 for details.
+ */
+#ifdef HAVE_SSIZE_T
+typedef ssize_t         Py_ssize_t;
+#elif SIZEOF_VOID_P == SIZEOF_SIZE_T
+typedef Py_intptr_t     Py_ssize_t;
+#else
+#   error "Python needs a typedef for Py_ssize_t in pyport.h."
+#endif
+
+/* Py_hash_t is the same size as a pointer. */
+#define SIZEOF_PY_HASH_T SIZEOF_SIZE_T
+typedef Py_ssize_t Py_hash_t;
+/* Py_uhash_t is the unsigned equivalent needed to calculate numeric hash. */
+#define SIZEOF_PY_UHASH_T SIZEOF_SIZE_T
+typedef size_t Py_uhash_t;
+
+/* Only used for compatibility with code that may not be PY_SSIZE_T_CLEAN. */
+#ifdef PY_SSIZE_T_CLEAN
+typedef Py_ssize_t Py_ssize_clean_t;
+#else
+typedef int Py_ssize_clean_t;
+#endif
+
+/* Largest possible value of size_t. */
+#define PY_SIZE_MAX SIZE_MAX
+
+/* Largest positive value of type Py_ssize_t. */
+#define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1))
+/* Smallest negative value of type Py_ssize_t. */
+#define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1)
+
+/* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf
+ * format to convert an argument with the width of a size_t or Py_ssize_t.
+ * C99 introduced "z" for this purpose, but old MSVCs had not supported it.
+ * Since MSVC supports "z" since (at least) 2015, we can just use "z"
+ * for new code.
+ *
+ * These "high level" Python format functions interpret "z" correctly on
+ * all platforms (Python interprets the format string itself, and does whatever
+ * the platform C requires to convert a size_t/Py_ssize_t argument):
+ *
+ *     PyBytes_FromFormat
+ *     PyErr_Format
+ *     PyBytes_FromFormatV
+ *     PyUnicode_FromFormatV
+ *
+ * Lower-level uses require that you interpolate the correct format modifier
+ * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for
+ * example,
+ *
+ *     Py_ssize_t index;
+ *     fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index);
+ *
+ * That will expand to %zd or to something else correct for a Py_ssize_t on
+ * the platform.
+ */
+#ifndef PY_FORMAT_SIZE_T
+#   define PY_FORMAT_SIZE_T "z"
+#endif
+
+/* Py_LOCAL can be used instead of static to get the fastest possible calling
+ * convention for functions that are local to a given module.
+ *
+ * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining,
+ * for platforms that support that.
+ *
+ * If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more
+ * "aggressive" inlining/optimization is enabled for the entire module.  This
+ * may lead to code bloat, and may slow things down for those reasons.  It may
+ * also lead to errors, if the code relies on pointer aliasing.  Use with
+ * care.
+ *
+ * NOTE: You can only use this for functions that are entirely local to a
+ * module; functions that are exported via method tables, callbacks, etc,
+ * should keep using static.
+ */
+
+#if defined(_MSC_VER)
+#  if defined(PY_LOCAL_AGGRESSIVE)
+   /* enable more aggressive optimization for visual studio */
+#  pragma optimize("agtw", on)
+#endif
+   /* ignore warnings if the compiler decides not to inline a function */
+#  pragma warning(disable: 4710)
+   /* fastest possible local call under MSVC */
+#  define Py_LOCAL(type) static type __fastcall
+#  define Py_LOCAL_INLINE(type) static __inline type __fastcall
+#else
+#  define Py_LOCAL(type) static type
+#  define Py_LOCAL_INLINE(type) static inline type
+#endif
+
+/* Py_MEMCPY is kept for backwards compatibility,
+ * see https://bugs.python.org/issue28126 */
+#define Py_MEMCPY memcpy
+
+#include 
+
+#ifdef HAVE_IEEEFP_H
+#include   /* needed for 'finite' declaration on some platforms */
+#endif
+
+#include  /* Moved here from the math section, before extern "C" */
+
+/********************************************
+ * WRAPPER FOR  and/or  *
+ ********************************************/
+
+#ifdef TIME_WITH_SYS_TIME
+#include 
+#include 
+#else /* !TIME_WITH_SYS_TIME */
+#ifdef HAVE_SYS_TIME_H
+#include 
+#else /* !HAVE_SYS_TIME_H */
+#include 
+#endif /* !HAVE_SYS_TIME_H */
+#endif /* !TIME_WITH_SYS_TIME */
+
+
+/******************************
+ * WRAPPER FOR  *
+ ******************************/
+
+/* NB caller must include  */
+
+#ifdef HAVE_SYS_SELECT_H
+#include 
+#endif /* !HAVE_SYS_SELECT_H */
+
+/*******************************
+ * stat() and fstat() fiddling *
+ *******************************/
+
+#ifdef HAVE_SYS_STAT_H
+#include 
+#elif defined(HAVE_STAT_H)
+#include 
+#endif
+
+#ifndef S_IFMT
+/* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */
+#define S_IFMT 0170000
+#endif
+
+#ifndef S_IFLNK
+/* Windows doesn't define S_IFLNK but posixmodule.c maps
+ * IO_REPARSE_TAG_SYMLINK to S_IFLNK */
+#  define S_IFLNK 0120000
+#endif
+
+#ifndef S_ISREG
+#define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
+#endif
+
+#ifndef S_ISDIR
+#define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR)
+#endif
+
+#ifndef S_ISCHR
+#define S_ISCHR(x) (((x) & S_IFMT) == S_IFCHR)
+#endif
+
+#ifdef __cplusplus
+/* Move this down here since some C++ #include's don't like to be included
+   inside an extern "C" */
+extern "C" {
+#endif
+
+
+/* Py_ARITHMETIC_RIGHT_SHIFT
+ * C doesn't define whether a right-shift of a signed integer sign-extends
+ * or zero-fills.  Here a macro to force sign extension:
+ * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J)
+ *    Return I >> J, forcing sign extension.  Arithmetically, return the
+ *    floor of I/2**J.
+ * Requirements:
+ *    I should have signed integer type.  In the terminology of C99, this can
+ *    be either one of the five standard signed integer types (signed char,
+ *    short, int, long, long long) or an extended signed integer type.
+ *    J is an integer >= 0 and strictly less than the number of bits in the
+ *    type of I (because C doesn't define what happens for J outside that
+ *    range either).
+ *    TYPE used to specify the type of I, but is now ignored.  It's been left
+ *    in for backwards compatibility with versions <= 2.6 or 3.0.
+ * Caution:
+ *    I may be evaluated more than once.
+ */
+#ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS
+#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \
+    ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J))
+#else
+#define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J))
+#endif
+
+/* Py_FORCE_EXPANSION(X)
+ * "Simply" returns its argument.  However, macro expansions within the
+ * argument are evaluated.  This unfortunate trickery is needed to get
+ * token-pasting to work as desired in some cases.
+ */
+#define Py_FORCE_EXPANSION(X) X
+
+/* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW)
+ * Cast VALUE to type NARROW from type WIDE.  In Py_DEBUG mode, this
+ * assert-fails if any information is lost.
+ * Caution:
+ *    VALUE may be evaluated more than once.
+ */
+#ifdef Py_DEBUG
+#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \
+    (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE))
+#else
+#define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE)
+#endif
+
+/* Py_SET_ERRNO_ON_MATH_ERROR(x)
+ * If a libm function did not set errno, but it looks like the result
+ * overflowed or not-a-number, set errno to ERANGE or EDOM.  Set errno
+ * to 0 before calling a libm function, and invoke this macro after,
+ * passing the function result.
+ * Caution:
+ *    This isn't reliable.  See Py_OVERFLOWED comments.
+ *    X is evaluated more than once.
+ */
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || (defined(__hpux) && defined(__ia64))
+#define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM;
+#else
+#define _Py_SET_EDOM_FOR_NAN(X) ;
+#endif
+#define Py_SET_ERRNO_ON_MATH_ERROR(X) \
+    do { \
+        if (errno == 0) { \
+            if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \
+                errno = ERANGE; \
+            else _Py_SET_EDOM_FOR_NAN(X) \
+        } \
+    } while(0)
+
+/* Py_SET_ERANGE_IF_OVERFLOW(x)
+ * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility.
+ */
+#define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X)
+
+/* Py_ADJUST_ERANGE1(x)
+ * Py_ADJUST_ERANGE2(x, y)
+ * Set errno to 0 before calling a libm function, and invoke one of these
+ * macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful
+ * for functions returning complex results).  This makes two kinds of
+ * adjustments to errno:  (A) If it looks like the platform libm set
+ * errno=ERANGE due to underflow, clear errno. (B) If it looks like the
+ * platform libm overflowed but didn't set errno, force errno to ERANGE.  In
+ * effect, we're trying to force a useful implementation of C89 errno
+ * behavior.
+ * Caution:
+ *    This isn't reliable.  See Py_OVERFLOWED comments.
+ *    X and Y may be evaluated more than once.
+ */
+#define Py_ADJUST_ERANGE1(X)                                            \
+    do {                                                                \
+        if (errno == 0) {                                               \
+            if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL)              \
+                errno = ERANGE;                                         \
+        }                                                               \
+        else if (errno == ERANGE && (X) == 0.0)                         \
+            errno = 0;                                                  \
+    } while(0)
+
+#define Py_ADJUST_ERANGE2(X, Y)                                         \
+    do {                                                                \
+        if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL ||                \
+            (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) {                \
+                        if (errno == 0)                                 \
+                                errno = ERANGE;                         \
+        }                                                               \
+        else if (errno == ERANGE)                                       \
+            errno = 0;                                                  \
+    } while(0)
+
+/*  The functions _Py_dg_strtod and _Py_dg_dtoa in Python/dtoa.c (which are
+ *  required to support the short float repr introduced in Python 3.1) require
+ *  that the floating-point unit that's being used for arithmetic operations
+ *  on C doubles is set to use 53-bit precision.  It also requires that the
+ *  FPU rounding mode is round-half-to-even, but that's less often an issue.
+ *
+ *  If your FPU isn't already set to 53-bit precision/round-half-to-even, and
+ *  you want to make use of _Py_dg_strtod and _Py_dg_dtoa, then you should
+ *
+ *     #define HAVE_PY_SET_53BIT_PRECISION 1
+ *
+ *  and also give appropriate definitions for the following three macros:
+ *
+ *    _PY_SET_53BIT_PRECISION_START : store original FPU settings, and
+ *        set FPU to 53-bit precision/round-half-to-even
+ *    _PY_SET_53BIT_PRECISION_END : restore original FPU settings
+ *    _PY_SET_53BIT_PRECISION_HEADER : any variable declarations needed to
+ *        use the two macros above.
+ *
+ * The macros are designed to be used within a single C function: see
+ * Python/pystrtod.c for an example of their use.
+ */
+
+/* get and set x87 control word for gcc/x86 */
+#ifdef HAVE_GCC_ASM_FOR_X87
+#define HAVE_PY_SET_53BIT_PRECISION 1
+/* _Py_get/set_387controlword functions are defined in Python/pymath.c */
+#define _Py_SET_53BIT_PRECISION_HEADER                          \
+    unsigned short old_387controlword, new_387controlword
+#define _Py_SET_53BIT_PRECISION_START                                   \
+    do {                                                                \
+        old_387controlword = _Py_get_387controlword();                  \
+        new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \
+        if (new_387controlword != old_387controlword)                   \
+            _Py_set_387controlword(new_387controlword);                 \
+    } while (0)
+#define _Py_SET_53BIT_PRECISION_END                             \
+    if (new_387controlword != old_387controlword)               \
+        _Py_set_387controlword(old_387controlword)
+#endif
+
+/* get and set x87 control word for VisualStudio/x86 */
+#if defined(_MSC_VER) && !defined(_WIN64) && !defined(_M_ARM) /* x87 not supported in 64-bit or ARM */
+#define HAVE_PY_SET_53BIT_PRECISION 1
+#define _Py_SET_53BIT_PRECISION_HEADER \
+    unsigned int old_387controlword, new_387controlword, out_387controlword
+/* We use the __control87_2 function to set only the x87 control word.
+   The SSE control word is unaffected. */
+#define _Py_SET_53BIT_PRECISION_START                                   \
+    do {                                                                \
+        __control87_2(0, 0, &old_387controlword, NULL);                 \
+        new_387controlword =                                            \
+          (old_387controlword & ~(_MCW_PC | _MCW_RC)) | (_PC_53 | _RC_NEAR); \
+        if (new_387controlword != old_387controlword)                   \
+            __control87_2(new_387controlword, _MCW_PC | _MCW_RC,        \
+                          &out_387controlword, NULL);                   \
+    } while (0)
+#define _Py_SET_53BIT_PRECISION_END                                     \
+    do {                                                                \
+        if (new_387controlword != old_387controlword)                   \
+            __control87_2(old_387controlword, _MCW_PC | _MCW_RC,        \
+                          &out_387controlword, NULL);                   \
+    } while (0)
+#endif
+
+#ifdef HAVE_GCC_ASM_FOR_MC68881
+#define HAVE_PY_SET_53BIT_PRECISION 1
+#define _Py_SET_53BIT_PRECISION_HEADER \
+  unsigned int old_fpcr, new_fpcr
+#define _Py_SET_53BIT_PRECISION_START                                   \
+  do {                                                                  \
+    __asm__ ("fmove.l %%fpcr,%0" : "=g" (old_fpcr));                    \
+    /* Set double precision / round to nearest.  */                     \
+    new_fpcr = (old_fpcr & ~0xf0) | 0x80;                               \
+    if (new_fpcr != old_fpcr)                                           \
+      __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (new_fpcr));        \
+  } while (0)
+#define _Py_SET_53BIT_PRECISION_END                                     \
+  do {                                                                  \
+    if (new_fpcr != old_fpcr)                                           \
+      __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (old_fpcr));        \
+  } while (0)
+#endif
+
+/* default definitions are empty */
+#ifndef HAVE_PY_SET_53BIT_PRECISION
+#define _Py_SET_53BIT_PRECISION_HEADER
+#define _Py_SET_53BIT_PRECISION_START
+#define _Py_SET_53BIT_PRECISION_END
+#endif
+
+/* If we can't guarantee 53-bit precision, don't use the code
+   in Python/dtoa.c, but fall back to standard code.  This
+   means that repr of a float will be long (17 sig digits).
+
+   Realistically, there are two things that could go wrong:
+
+   (1) doubles aren't IEEE 754 doubles, or
+   (2) we're on x86 with the rounding precision set to 64-bits
+       (extended precision), and we don't know how to change
+       the rounding precision.
+ */
+
+#if !defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \
+    !defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \
+    !defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754)
+#define PY_NO_SHORT_FLOAT_REPR
+#endif
+
+/* double rounding is symptomatic of use of extended precision on x86.  If
+   we're seeing double rounding, and we don't have any mechanism available for
+   changing the FPU rounding precision, then don't use Python/dtoa.c. */
+#if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION)
+#define PY_NO_SHORT_FLOAT_REPR
+#endif
+
+
+/* Py_DEPRECATED(version)
+ * Declare a variable, type, or function deprecated.
+ * The macro must be placed before the declaration.
+ * Usage:
+ *    Py_DEPRECATED(3.3) extern int old_var;
+ *    Py_DEPRECATED(3.4) typedef int T1;
+ *    Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void);
+ */
+#if defined(__GNUC__) \
+    && ((__GNUC__ >= 4) || (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
+#define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__))
+#elif defined(_MSC_VER)
+#define Py_DEPRECATED(VERSION) __declspec(deprecated( \
+                                          "deprecated in " #VERSION))
+#else
+#define Py_DEPRECATED(VERSION_UNUSED)
+#endif
+
+#if defined(__clang__)
+#define _Py_COMP_DIAG_PUSH _Pragma("clang diagnostic push")
+#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#define _Py_COMP_DIAG_POP _Pragma("clang diagnostic pop")
+#elif defined(__GNUC__) \
+    && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6))
+#define _Py_COMP_DIAG_PUSH _Pragma("GCC diagnostic push")
+#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \
+    _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#define _Py_COMP_DIAG_POP _Pragma("GCC diagnostic pop")
+#elif defined(_MSC_VER)
+#define _Py_COMP_DIAG_PUSH __pragma(warning(push))
+#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS __pragma(warning(disable: 4996))
+#define _Py_COMP_DIAG_POP __pragma(warning(pop))
+#else
+#define _Py_COMP_DIAG_PUSH
+#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS
+#define _Py_COMP_DIAG_POP
+#endif
+
+/* _Py_HOT_FUNCTION
+ * The hot attribute on a function is used to inform the compiler that the
+ * function is a hot spot of the compiled program. The function is optimized
+ * more aggressively and on many target it is placed into special subsection of
+ * the text section so all hot functions appears close together improving
+ * locality.
+ *
+ * Usage:
+ *    int _Py_HOT_FUNCTION x(void) { return 3; }
+ *
+ * Issue #28618: This attribute must not be abused, otherwise it can have a
+ * negative effect on performance. Only the functions were Python spend most of
+ * its time must use it. Use a profiler when running performance benchmark
+ * suite to find these functions.
+ */
+#if defined(__GNUC__) \
+    && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))
+#define _Py_HOT_FUNCTION __attribute__((hot))
+#else
+#define _Py_HOT_FUNCTION
+#endif
+
+/* _Py_NO_INLINE
+ * Disable inlining on a function. For example, it helps to reduce the C stack
+ * consumption.
+ *
+ * Usage:
+ *    int _Py_NO_INLINE x(void) { return 3; }
+ */
+#if defined(_MSC_VER)
+#  define _Py_NO_INLINE __declspec(noinline)
+#elif defined(__GNUC__) || defined(__clang__)
+#  define _Py_NO_INLINE __attribute__ ((noinline))
+#else
+#  define _Py_NO_INLINE
+#endif
+
+/**************************************************************************
+Prototypes that are missing from the standard include files on some systems
+(and possibly only some versions of such systems.)
+
+Please be conservative with adding new ones, document them and enclose them
+in platform-specific #ifdefs.
+**************************************************************************/
+
+#ifdef SOLARIS
+/* Unchecked */
+extern int gethostname(char *, int);
+#endif
+
+#ifdef HAVE__GETPTY
+#include           /* we need to import mode_t */
+extern char * _getpty(int *, int, mode_t, int);
+#endif
+
+/* On QNX 6, struct termio must be declared by including sys/termio.h
+   if TCGETA, TCSETA, TCSETAW, or TCSETAF are used.  sys/termio.h must
+   be included before termios.h or it will generate an error. */
+#if defined(HAVE_SYS_TERMIO_H) && !defined(__hpux)
+#include 
+#endif
+
+
+/* On 4.4BSD-descendants, ctype functions serves the whole range of
+ * wchar_t character set rather than single byte code points only.
+ * This characteristic can break some operations of string object
+ * including str.upper() and str.split() on UTF-8 locales.  This
+ * workaround was provided by Tim Robbins of FreeBSD project.
+ */
+
+#if defined(__APPLE__)
+#  define _PY_PORT_CTYPE_UTF8_ISSUE
+#endif
+
+#ifdef _PY_PORT_CTYPE_UTF8_ISSUE
+#ifndef __cplusplus
+   /* The workaround below is unsafe in C++ because
+    * the  defines these symbols as real functions,
+    * with a slightly different signature.
+    * See issue #10910
+    */
+#include 
+#include 
+#undef isalnum
+#define isalnum(c) iswalnum(btowc(c))
+#undef isalpha
+#define isalpha(c) iswalpha(btowc(c))
+#undef islower
+#define islower(c) iswlower(btowc(c))
+#undef isspace
+#define isspace(c) iswspace(btowc(c))
+#undef isupper
+#define isupper(c) iswupper(btowc(c))
+#undef tolower
+#define tolower(c) towlower(btowc(c))
+#undef toupper
+#define toupper(c) towupper(btowc(c))
+#endif
+#endif
+
+
+/* Declarations for symbol visibility.
+
+  PyAPI_FUNC(type): Declares a public Python API function and return type
+  PyAPI_DATA(type): Declares public Python data and its type
+  PyMODINIT_FUNC:   A Python module init function.  If these functions are
+                    inside the Python core, they are private to the core.
+                    If in an extension module, it may be declared with
+                    external linkage depending on the platform.
+
+  As a number of platforms support/require "__declspec(dllimport/dllexport)",
+  we support a HAVE_DECLSPEC_DLL macro to save duplication.
+*/
+
+/*
+  All windows ports, except cygwin, are handled in PC/pyconfig.h.
+
+  Cygwin is the only other autoconf platform requiring special
+  linkage handling and it uses __declspec().
+*/
+#if defined(__CYGWIN__)
+#       define HAVE_DECLSPEC_DLL
+#endif
+
+#include "exports.h"
+
+/* only get special linkage if built as shared or platform is Cygwin */
+#if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__)
+#       if defined(HAVE_DECLSPEC_DLL)
+#               if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#                       define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE
+#                       define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE
+        /* module init functions inside the core need no external linkage */
+        /* except for Cygwin to handle embedding */
+#                       if defined(__CYGWIN__)
+#                               define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject*
+#                       else /* __CYGWIN__ */
+#                               define PyMODINIT_FUNC PyObject*
+#                       endif /* __CYGWIN__ */
+#               else /* Py_BUILD_CORE */
+        /* Building an extension module, or an embedded situation */
+        /* public Python functions and data are imported */
+        /* Under Cygwin, auto-import functions to prevent compilation */
+        /* failures similar to those described at the bottom of 4.1: */
+        /* http://docs.python.org/extending/windows.html#a-cookbook-approach */
+#                       if !defined(__CYGWIN__)
+#                               define PyAPI_FUNC(RTYPE) Py_IMPORTED_SYMBOL RTYPE
+#                       endif /* !__CYGWIN__ */
+#                       define PyAPI_DATA(RTYPE) extern Py_IMPORTED_SYMBOL RTYPE
+        /* module init functions outside the core must be exported */
+#                       if defined(__cplusplus)
+#                               define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject*
+#                       else /* __cplusplus */
+#                               define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject*
+#                       endif /* __cplusplus */
+#               endif /* Py_BUILD_CORE */
+#       endif /* HAVE_DECLSPEC_DLL */
+#endif /* Py_ENABLE_SHARED */
+
+/* If no external linkage macros defined by now, create defaults */
+#ifndef PyAPI_FUNC
+#       define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE
+#endif
+#ifndef PyAPI_DATA
+#       define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE
+#endif
+#ifndef PyMODINIT_FUNC
+#       if defined(__cplusplus)
+#               define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject*
+#       else /* __cplusplus */
+#               define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject*
+#       endif /* __cplusplus */
+#endif
+
+/* limits.h constants that may be missing */
+
+#ifndef INT_MAX
+#define INT_MAX 2147483647
+#endif
+
+#ifndef LONG_MAX
+#if SIZEOF_LONG == 4
+#define LONG_MAX 0X7FFFFFFFL
+#elif SIZEOF_LONG == 8
+#define LONG_MAX 0X7FFFFFFFFFFFFFFFL
+#else
+#error "could not set LONG_MAX in pyport.h"
+#endif
+#endif
+
+#ifndef LONG_MIN
+#define LONG_MIN (-LONG_MAX-1)
+#endif
+
+#ifndef LONG_BIT
+#define LONG_BIT (8 * SIZEOF_LONG)
+#endif
+
+#if LONG_BIT != 8 * SIZEOF_LONG
+/* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent
+ * 32-bit platforms using gcc.  We try to catch that here at compile-time
+ * rather than waiting for integer multiplication to trigger bogus
+ * overflows.
+ */
+#error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)."
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/*
+ * Hide GCC attributes from compilers that don't support them.
+ */
+#if (!defined(__GNUC__) || __GNUC__ < 2 || \
+     (__GNUC__ == 2 && __GNUC_MINOR__ < 7) )
+#define Py_GCC_ATTRIBUTE(x)
+#else
+#define Py_GCC_ATTRIBUTE(x) __attribute__(x)
+#endif
+
+/*
+ * Specify alignment on compilers that support it.
+ */
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define Py_ALIGNED(x) __attribute__((aligned(x)))
+#else
+#define Py_ALIGNED(x)
+#endif
+
+/* Eliminate end-of-loop code not reached warnings from SunPro C
+ * when using do{...}while(0) macros
+ */
+#ifdef __SUNPRO_C
+#pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED)
+#endif
+
+#ifndef Py_LL
+#define Py_LL(x) x##LL
+#endif
+
+#ifndef Py_ULL
+#define Py_ULL(x) Py_LL(x##U)
+#endif
+
+#define Py_VA_COPY va_copy
+
+/*
+ * Convenient macros to deal with endianness of the platform. WORDS_BIGENDIAN is
+ * detected by configure and defined in pyconfig.h. The code in pyconfig.h
+ * also takes care of Apple's universal builds.
+ */
+
+#ifdef WORDS_BIGENDIAN
+#  define PY_BIG_ENDIAN 1
+#  define PY_LITTLE_ENDIAN 0
+#else
+#  define PY_BIG_ENDIAN 0
+#  define PY_LITTLE_ENDIAN 1
+#endif
+
+#ifdef Py_BUILD_CORE
+/*
+ * Macros to protect CRT calls against instant termination when passed an
+ * invalid parameter (issue23524).
+ */
+#if defined _MSC_VER && _MSC_VER >= 1900
+
+extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler;
+#define _Py_BEGIN_SUPPRESS_IPH { _invalid_parameter_handler _Py_old_handler = \
+    _set_thread_local_invalid_parameter_handler(_Py_silent_invalid_parameter_handler);
+#define _Py_END_SUPPRESS_IPH _set_thread_local_invalid_parameter_handler(_Py_old_handler); }
+
+#else
+
+#define _Py_BEGIN_SUPPRESS_IPH
+#define _Py_END_SUPPRESS_IPH
+
+#endif /* _MSC_VER >= 1900 */
+#endif /* Py_BUILD_CORE */
+
+#ifdef __ANDROID__
+   /* The Android langinfo.h header is not used. */
+#  undef HAVE_LANGINFO_H
+#  undef CODESET
+#endif
+
+/* Maximum value of the Windows DWORD type */
+#define PY_DWORD_MAX 4294967295U
+
+/* This macro used to tell whether Python was built with multithreading
+ * enabled.  Now multithreading is always enabled, but keep the macro
+ * for compatibility.
+ */
+#ifndef WITH_THREAD
+#  define WITH_THREAD
+#endif
+
+/* Check that ALT_SOABI is consistent with Py_TRACE_REFS:
+   ./configure --with-trace-refs should must be used to define Py_TRACE_REFS */
+#if defined(ALT_SOABI) && defined(Py_TRACE_REFS)
+#  error "Py_TRACE_REFS ABI is not compatible with release and debug ABI"
+#endif
+
+#if defined(__ANDROID__) || defined(__VXWORKS__)
+   /* Ignore the locale encoding: force UTF-8 */
+#  define _Py_FORCE_UTF8_LOCALE
+#endif
+
+#if defined(_Py_FORCE_UTF8_LOCALE) || defined(__APPLE__)
+   /* Use UTF-8 as filesystem encoding */
+#  define _Py_FORCE_UTF8_FS_ENCODING
+#endif
+
+/* Mark a function which cannot return. Example:
+   PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void);
+
+   XLC support is intentionally omitted due to bpo-40244 */
+#if defined(__clang__) || \
+    (defined(__GNUC__) && \
+     ((__GNUC__ >= 3) || \
+      (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5)))
+#  define _Py_NO_RETURN __attribute__((__noreturn__))
+#elif defined(_MSC_VER)
+#  define _Py_NO_RETURN __declspec(noreturn)
+#else
+#  define _Py_NO_RETURN
+#endif
+
+
+// Preprocessor check for a builtin preprocessor function. Always return 0
+// if __has_builtin() macro is not defined.
+//
+// __has_builtin() is available on clang and GCC 10.
+#ifdef __has_builtin
+#  define _Py__has_builtin(x) __has_builtin(x)
+#else
+#  define _Py__has_builtin(x) 0
+#endif
+
+
+#endif /* Py_PYPORT_H */
diff --git a/marketing/include/pystate.h b/marketing/include/pystate.h
new file mode 100644
index 0000000000000000000000000000000000000000..bae440778b261a425f080aaf085a9d6d72811615
--- /dev/null
+++ b/marketing/include/pystate.h
@@ -0,0 +1,150 @@
+/* Thread and interpreter state structures and their interfaces */
+
+
+#ifndef Py_PYSTATE_H
+#define Py_PYSTATE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This limitation is for performance and simplicity. If needed it can be
+removed (with effort). */
+#define MAX_CO_EXTRA_USERS 255
+
+/* Forward declarations for PyFrameObject, PyThreadState
+   and PyInterpreterState */
+struct _ts;
+struct _is;
+
+/* struct _ts is defined in cpython/pystate.h */
+typedef struct _ts PyThreadState;
+/* struct _is is defined in internal/pycore_interp.h */
+typedef struct _is PyInterpreterState;
+
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void);
+PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *);
+PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
+/* New in 3.9 */
+/* Get the current interpreter state.
+
+   Issue a fatal error if there no current Python thread state or no current
+   interpreter. It cannot return NULL.
+
+   The caller must hold the GIL. */
+PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Get(void);
+#endif
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03080000
+/* New in 3.8 */
+PyAPI_FUNC(PyObject *) PyInterpreterState_GetDict(PyInterpreterState *);
+#endif
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
+/* New in 3.7 */
+PyAPI_FUNC(int64_t) PyInterpreterState_GetID(PyInterpreterState *);
+#endif
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+
+/* State unique per thread */
+
+/* New in 3.3 */
+PyAPI_FUNC(int) PyState_AddModule(PyObject*, struct PyModuleDef*);
+PyAPI_FUNC(int) PyState_RemoveModule(struct PyModuleDef*);
+#endif
+PyAPI_FUNC(PyObject*) PyState_FindModule(struct PyModuleDef*);
+
+PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
+PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
+PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
+
+/* Get the current thread state.
+
+   When the current thread state is NULL, this issues a fatal error (so that
+   the caller needn't check for NULL).
+
+   The caller must hold the GIL.
+
+   See also PyThreadState_GET() and _PyThreadState_GET(). */
+PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);
+
+/* Get the current Python thread state.
+
+   Macro using PyThreadState_Get() or _PyThreadState_GET() depending if
+   pycore_pystate.h is included or not (this header redefines the macro).
+
+   If PyThreadState_Get() is used, issue a fatal error if the current thread
+   state is NULL.
+
+   See also PyThreadState_Get() and _PyThreadState_GET(). */
+#define PyThreadState_GET() PyThreadState_Get()
+
+PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *);
+PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);
+PyAPI_FUNC(int) PyThreadState_SetAsyncExc(unsigned long, PyObject *);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000
+/* New in 3.9 */
+PyAPI_FUNC(PyInterpreterState*) PyThreadState_GetInterpreter(PyThreadState *tstate);
+PyAPI_FUNC(PyFrameObject*) PyThreadState_GetFrame(PyThreadState *tstate);
+PyAPI_FUNC(uint64_t) PyThreadState_GetID(PyThreadState *tstate);
+#endif
+
+typedef
+    enum {PyGILState_LOCKED, PyGILState_UNLOCKED}
+        PyGILState_STATE;
+
+
+/* Ensure that the current thread is ready to call the Python
+   C API, regardless of the current state of Python, or of its
+   thread lock.  This may be called as many times as desired
+   by a thread so long as each call is matched with a call to
+   PyGILState_Release().  In general, other thread-state APIs may
+   be used between _Ensure() and _Release() calls, so long as the
+   thread-state is restored to its previous state before the Release().
+   For example, normal use of the Py_BEGIN_ALLOW_THREADS/
+   Py_END_ALLOW_THREADS macros are acceptable.
+
+   The return value is an opaque "handle" to the thread state when
+   PyGILState_Ensure() was called, and must be passed to
+   PyGILState_Release() to ensure Python is left in the same state. Even
+   though recursive calls are allowed, these handles can *not* be shared -
+   each unique call to PyGILState_Ensure must save the handle for its
+   call to PyGILState_Release.
+
+   When the function returns, the current thread will hold the GIL.
+
+   Failure is a fatal error.
+*/
+PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void);
+
+/* Release any resources previously acquired.  After this call, Python's
+   state will be the same as it was prior to the corresponding
+   PyGILState_Ensure() call (but generally this state will be unknown to
+   the caller, hence the use of the GILState API.)
+
+   Every call to PyGILState_Ensure must be matched by a call to
+   PyGILState_Release on the same thread.
+*/
+PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE);
+
+/* Helper/diagnostic function - get the current thread state for
+   this thread.  May return NULL if no GILState API has been used
+   on the current thread.  Note that the main thread always has such a
+   thread-state, even if no auto-thread-state call has been made
+   on the main thread.
+*/
+PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void);
+
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_PYSTATE_H
+#  include  "cpython/pystate.h"
+#  undef Py_CPYTHON_PYSTATE_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PYSTATE_H */
diff --git a/marketing/include/pystrcmp.h b/marketing/include/pystrcmp.h
new file mode 100644
index 0000000000000000000000000000000000000000..edb12397e3cbcc761a5ba28221215a62193a48ba
--- /dev/null
+++ b/marketing/include/pystrcmp.h
@@ -0,0 +1,23 @@
+#ifndef Py_STRCMP_H
+#define Py_STRCMP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(int) PyOS_mystrnicmp(const char *, const char *, Py_ssize_t);
+PyAPI_FUNC(int) PyOS_mystricmp(const char *, const char *);
+
+#ifdef MS_WINDOWS
+#define PyOS_strnicmp strnicmp
+#define PyOS_stricmp stricmp
+#else
+#define PyOS_strnicmp PyOS_mystrnicmp
+#define PyOS_stricmp PyOS_mystricmp
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_STRCMP_H */
diff --git a/marketing/include/pystrhex.h b/marketing/include/pystrhex.h
new file mode 100644
index 0000000000000000000000000000000000000000..a4f36305bac69bd84684a5ef4d26d1e091e24232
--- /dev/null
+++ b/marketing/include/pystrhex.h
@@ -0,0 +1,22 @@
+#ifndef Py_STRHEX_H
+#define Py_STRHEX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+/* Returns a str() containing the hex representation of argbuf. */
+PyAPI_FUNC(PyObject*) _Py_strhex(const char* argbuf, const Py_ssize_t arglen);
+/* Returns a bytes() containing the ASCII hex representation of argbuf. */
+PyAPI_FUNC(PyObject*) _Py_strhex_bytes(const char* argbuf, const Py_ssize_t arglen);
+/* These variants include support for a separator between every N bytes: */
+PyAPI_FUNC(PyObject*) _Py_strhex_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group);
+PyAPI_FUNC(PyObject*) _Py_strhex_bytes_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group);
+#endif /* !Py_LIMITED_API */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_STRHEX_H */
diff --git a/marketing/include/pystrtod.h b/marketing/include/pystrtod.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1e84de6fe54287cd8dcdfa6147f8b1e31cc3400
--- /dev/null
+++ b/marketing/include/pystrtod.h
@@ -0,0 +1,45 @@
+#ifndef Py_STRTOD_H
+#define Py_STRTOD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+PyAPI_FUNC(double) PyOS_string_to_double(const char *str,
+                                         char **endptr,
+                                         PyObject *overflow_exception);
+
+/* The caller is responsible for calling PyMem_Free to free the buffer
+   that's is returned. */
+PyAPI_FUNC(char *) PyOS_double_to_string(double val,
+                                         char format_code,
+                                         int precision,
+                                         int flags,
+                                         int *type);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _Py_string_to_number_with_underscores(
+    const char *str, Py_ssize_t len, const char *what, PyObject *obj, void *arg,
+    PyObject *(*innerfunc)(const char *, Py_ssize_t, void *));
+
+PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char *p, char **endptr);
+#endif
+
+
+/* PyOS_double_to_string's "flags" parameter can be set to 0 or more of: */
+#define Py_DTSF_SIGN      0x01 /* always add the sign */
+#define Py_DTSF_ADD_DOT_0 0x02 /* if the result is an integer add ".0" */
+#define Py_DTSF_ALT       0x04 /* "alternate" formatting. it's format_code
+                                  specific */
+
+/* PyOS_double_to_string's "type", if non-NULL, will be set to one of: */
+#define Py_DTST_FINITE 0
+#define Py_DTST_INFINITE 1
+#define Py_DTST_NAN 2
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_STRTOD_H */
diff --git a/marketing/include/pythonrun.h b/marketing/include/pythonrun.h
new file mode 100644
index 0000000000000000000000000000000000000000..57529072432ea75545e8a24da37c88282113b6c0
--- /dev/null
+++ b/marketing/include/pythonrun.h
@@ -0,0 +1,217 @@
+
+/* Interfaces to parse and execute pieces of python code */
+
+#ifndef Py_PYTHONRUN_H
+#define Py_PYTHONRUN_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char *, PyCompilerFlags *);
+PyAPI_FUNC(int) PyRun_AnyFileExFlags(
+    FILE *fp,
+    const char *filename,       /* decoded from the filesystem encoding */
+    int closeit,
+    PyCompilerFlags *flags);
+PyAPI_FUNC(int) PyRun_SimpleFileExFlags(
+    FILE *fp,
+    const char *filename,       /* decoded from the filesystem encoding */
+    int closeit,
+    PyCompilerFlags *flags);
+PyAPI_FUNC(int) PyRun_InteractiveOneFlags(
+    FILE *fp,
+    const char *filename,       /* decoded from the filesystem encoding */
+    PyCompilerFlags *flags);
+PyAPI_FUNC(int) PyRun_InteractiveOneObject(
+    FILE *fp,
+    PyObject *filename,
+    PyCompilerFlags *flags);
+PyAPI_FUNC(int) PyRun_InteractiveLoopFlags(
+    FILE *fp,
+    const char *filename,       /* decoded from the filesystem encoding */
+    PyCompilerFlags *flags);
+
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(
+    const char *s,
+    const char *filename,       /* decoded from the filesystem encoding */
+    int start,
+    PyCompilerFlags *flags,
+    PyArena *arena);
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromStringObject(
+    const char *s,
+    PyObject *filename,
+    int start,
+    PyCompilerFlags *flags,
+    PyArena *arena);
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(
+    FILE *fp,
+    const char *filename,       /* decoded from the filesystem encoding */
+    const char* enc,
+    int start,
+    const char *ps1,
+    const char *ps2,
+    PyCompilerFlags *flags,
+    int *errcode,
+    PyArena *arena);
+PyAPI_FUNC(struct _mod *) PyParser_ASTFromFileObject(
+    FILE *fp,
+    PyObject *filename,
+    const char* enc,
+    int start,
+    const char *ps1,
+    const char *ps2,
+    PyCompilerFlags *flags,
+    int *errcode,
+    PyArena *arena);
+#endif
+
+#ifndef PyParser_SimpleParseString
+#define PyParser_SimpleParseString(S, B) \
+    PyParser_SimpleParseStringFlags(S, B, 0)
+#define PyParser_SimpleParseFile(FP, S, B) \
+    PyParser_SimpleParseFileFlags(FP, S, B, 0)
+#endif
+
+#ifndef Py_BUILD_CORE
+Py_DEPRECATED(3.9)
+#endif
+PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int, int);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+#ifndef Py_BUILD_CORE
+Py_DEPRECATED(3.9)
+#endif
+PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlagsFilename(const char *,
+                                                                   const char *,
+                                                                   int, int);
+#endif
+#ifndef Py_BUILD_CORE
+Py_DEPRECATED(3.9)
+#endif
+PyAPI_FUNC(struct _node *) PyParser_SimpleParseFileFlags(FILE *, const char *, int, int);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *,
+                                         PyObject *, PyCompilerFlags *);
+
+PyAPI_FUNC(PyObject *) PyRun_FileExFlags(
+    FILE *fp,
+    const char *filename,       /* decoded from the filesystem encoding */
+    int start,
+    PyObject *globals,
+    PyObject *locals,
+    int closeit,
+    PyCompilerFlags *flags);
+#endif
+
+#ifdef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) Py_CompileString(const char *, const char *, int);
+#else
+#define Py_CompileString(str, p, s) Py_CompileStringExFlags(str, p, s, NULL, -1)
+#define Py_CompileStringFlags(str, p, s, f) Py_CompileStringExFlags(str, p, s, f, -1)
+PyAPI_FUNC(PyObject *) Py_CompileStringExFlags(
+    const char *str,
+    const char *filename,       /* decoded from the filesystem encoding */
+    int start,
+    PyCompilerFlags *flags,
+    int optimize);
+PyAPI_FUNC(PyObject *) Py_CompileStringObject(
+    const char *str,
+    PyObject *filename, int start,
+    PyCompilerFlags *flags,
+    int optimize);
+#endif
+PyAPI_FUNC(struct symtable *) Py_SymtableString(
+    const char *str,
+    const char *filename,       /* decoded from the filesystem encoding */
+    int start);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(const char *) _Py_SourceAsString(
+    PyObject *cmd,
+    const char *funcname,
+    const char *what,
+    PyCompilerFlags *cf,
+    PyObject **cmd_copy);
+
+PyAPI_FUNC(struct symtable *) Py_SymtableStringObject(
+    const char *str,
+    PyObject *filename,
+    int start);
+
+PyAPI_FUNC(struct symtable *) _Py_SymtableStringObjectFlags(
+    const char *str,
+    PyObject *filename,
+    int start,
+    PyCompilerFlags *flags);
+#endif
+
+PyAPI_FUNC(void) PyErr_Print(void);
+PyAPI_FUNC(void) PyErr_PrintEx(int);
+PyAPI_FUNC(void) PyErr_Display(PyObject *, PyObject *, PyObject *);
+
+#ifndef Py_LIMITED_API
+/* A function flavor is also exported by libpython. It is required when
+    libpython is accessed directly rather than using header files which defines
+    macros below. On Windows, for example, PyAPI_FUNC() uses dllexport to
+    export functions in pythonXX.dll. */
+PyAPI_FUNC(PyObject *) PyRun_String(const char *str, int s, PyObject *g, PyObject *l);
+PyAPI_FUNC(int) PyRun_AnyFile(FILE *fp, const char *name);
+PyAPI_FUNC(int) PyRun_AnyFileEx(FILE *fp, const char *name, int closeit);
+PyAPI_FUNC(int) PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *);
+PyAPI_FUNC(int) PyRun_SimpleString(const char *s);
+PyAPI_FUNC(int) PyRun_SimpleFile(FILE *f, const char *p);
+PyAPI_FUNC(int) PyRun_SimpleFileEx(FILE *f, const char *p, int c);
+PyAPI_FUNC(int) PyRun_InteractiveOne(FILE *f, const char *p);
+PyAPI_FUNC(int) PyRun_InteractiveLoop(FILE *f, const char *p);
+PyAPI_FUNC(PyObject *) PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l);
+PyAPI_FUNC(PyObject *) PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c);
+PyAPI_FUNC(PyObject *) PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, PyCompilerFlags *flags);
+
+/* Use macros for a bunch of old variants */
+#define PyRun_String(str, s, g, l) PyRun_StringFlags(str, s, g, l, NULL)
+#define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL)
+#define PyRun_AnyFileEx(fp, name, closeit) \
+    PyRun_AnyFileExFlags(fp, name, closeit, NULL)
+#define PyRun_AnyFileFlags(fp, name, flags) \
+    PyRun_AnyFileExFlags(fp, name, 0, flags)
+#define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL)
+#define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL)
+#define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags(f, p, c, NULL)
+#define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags(f, p, NULL)
+#define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL)
+#define PyRun_File(fp, p, s, g, l) \
+    PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
+#define PyRun_FileEx(fp, p, s, g, l, c) \
+    PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
+#define PyRun_FileFlags(fp, p, s, g, l, flags) \
+    PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
+#endif
+
+/* Stuff with no proper home (yet) */
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, const char *);
+#endif
+PyAPI_DATA(int) (*PyOS_InputHook)(void);
+PyAPI_DATA(char) *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *);
+#ifndef Py_LIMITED_API
+PyAPI_DATA(PyThreadState*) _PyOS_ReadlineTState;
+#endif
+
+/* Stack size, in "pointers" (so we get extra safety margins
+   on 64-bit platforms).  On a 32-bit platform, this translates
+   to an 8k margin. */
+#define PYOS_STACK_MARGIN 2048
+
+#if defined(WIN32) && !defined(MS_WIN64) && !defined(_M_ARM) && defined(_MSC_VER) && _MSC_VER >= 1300
+/* Enable stack checking under Microsoft C */
+#define USE_STACKCHECK
+#endif
+
+#ifdef USE_STACKCHECK
+/* Check that we aren't overflowing our stack */
+PyAPI_FUNC(int) PyOS_CheckStack(void);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_PYTHONRUN_H */
diff --git a/marketing/include/pythread.h b/marketing/include/pythread.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb9d86412218ad24b189f7b8e221e56e4491b26c
--- /dev/null
+++ b/marketing/include/pythread.h
@@ -0,0 +1,169 @@
+
+#ifndef Py_PYTHREAD_H
+#define Py_PYTHREAD_H
+
+typedef void *PyThread_type_lock;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Return status codes for Python lock acquisition.  Chosen for maximum
+ * backwards compatibility, ie failure -> 0, success -> 1.  */
+typedef enum PyLockStatus {
+    PY_LOCK_FAILURE = 0,
+    PY_LOCK_ACQUIRED = 1,
+    PY_LOCK_INTR
+} PyLockStatus;
+
+#ifndef Py_LIMITED_API
+#define PYTHREAD_INVALID_THREAD_ID ((unsigned long)-1)
+#endif
+
+PyAPI_FUNC(void) PyThread_init_thread(void);
+PyAPI_FUNC(unsigned long) PyThread_start_new_thread(void (*)(void *), void *);
+PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void);
+PyAPI_FUNC(unsigned long) PyThread_get_thread_ident(void);
+
+#if defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(_WIN32) || defined(_AIX)
+#define PY_HAVE_THREAD_NATIVE_ID
+PyAPI_FUNC(unsigned long) PyThread_get_thread_native_id(void);
+#endif
+
+PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void);
+PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock);
+PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int);
+#define WAIT_LOCK       1
+#define NOWAIT_LOCK     0
+
+#ifndef Py_LIMITED_API
+#ifdef HAVE_FORK
+/* Private function to reinitialize a lock at fork in the child process.
+   Reset the lock to the unlocked state.
+   Return 0 on success, return -1 on error. */
+PyAPI_FUNC(int) _PyThread_at_fork_reinit(PyThread_type_lock *lock);
+#endif  /* HAVE_FORK */
+#endif  /* !Py_LIMITED_API */
+
+/* PY_TIMEOUT_T is the integral type used to specify timeouts when waiting
+   on a lock (see PyThread_acquire_lock_timed() below).
+   PY_TIMEOUT_MAX is the highest usable value (in microseconds) of that
+   type, and depends on the system threading API.
+
+   NOTE: this isn't the same value as `_thread.TIMEOUT_MAX`.  The _thread
+   module exposes a higher-level API, with timeouts expressed in seconds
+   and floating-point numbers allowed.
+*/
+#define PY_TIMEOUT_T long long
+
+#if defined(_POSIX_THREADS)
+   /* PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000),
+      convert microseconds to nanoseconds. */
+#  define PY_TIMEOUT_MAX (LLONG_MAX / 1000)
+#elif defined (NT_THREADS)
+   /* In the NT API, the timeout is a DWORD and is expressed in milliseconds */
+#  if 0xFFFFFFFFLL * 1000 < LLONG_MAX
+#    define PY_TIMEOUT_MAX (0xFFFFFFFFLL * 1000)
+#  else
+#    define PY_TIMEOUT_MAX LLONG_MAX
+#  endif
+#else
+#  define PY_TIMEOUT_MAX LLONG_MAX
+#endif
+
+
+/* If microseconds == 0, the call is non-blocking: it returns immediately
+   even when the lock can't be acquired.
+   If microseconds > 0, the call waits up to the specified duration.
+   If microseconds < 0, the call waits until success (or abnormal failure)
+
+   microseconds must be less than PY_TIMEOUT_MAX. Behaviour otherwise is
+   undefined.
+
+   If intr_flag is true and the acquire is interrupted by a signal, then the
+   call will return PY_LOCK_INTR.  The caller may reattempt to acquire the
+   lock.
+*/
+PyAPI_FUNC(PyLockStatus) PyThread_acquire_lock_timed(PyThread_type_lock,
+                                                     PY_TIMEOUT_T microseconds,
+                                                     int intr_flag);
+
+PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock);
+
+PyAPI_FUNC(size_t) PyThread_get_stacksize(void);
+PyAPI_FUNC(int) PyThread_set_stacksize(size_t);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject*) PyThread_GetInfo(void);
+#endif
+
+
+/* Thread Local Storage (TLS) API
+   TLS API is DEPRECATED.  Use Thread Specific Storage (TSS) API.
+
+   The existing TLS API has used int to represent TLS keys across all
+   platforms, but it is not POSIX-compliant.  Therefore, the new TSS API uses
+   opaque data type to represent TSS keys to be compatible (see PEP 539).
+*/
+Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_create_key(void);
+Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key(int key);
+Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_set_key_value(int key,
+                                                          void *value);
+Py_DEPRECATED(3.7) PyAPI_FUNC(void *) PyThread_get_key_value(int key);
+Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key_value(int key);
+
+/* Cleanup after a fork */
+Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_ReInitTLS(void);
+
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
+/* New in 3.7 */
+/* Thread Specific Storage (TSS) API */
+
+typedef struct _Py_tss_t Py_tss_t;  /* opaque */
+
+#ifndef Py_LIMITED_API
+#if defined(_POSIX_THREADS)
+    /* Darwin needs pthread.h to know type name the pthread_key_t. */
+#   include 
+#   define NATIVE_TSS_KEY_T     pthread_key_t
+#elif defined(NT_THREADS)
+    /* In Windows, native TSS key type is DWORD,
+       but hardcode the unsigned long to avoid errors for include directive.
+    */
+#   define NATIVE_TSS_KEY_T     unsigned long
+#else
+#   error "Require native threads. See https://bugs.python.org/issue31370"
+#endif
+
+/* When Py_LIMITED_API is not defined, the type layout of Py_tss_t is
+   exposed to allow static allocation in the API clients.  Even in this case,
+   you must handle TSS keys through API functions due to compatibility.
+*/
+struct _Py_tss_t {
+    int _is_initialized;
+    NATIVE_TSS_KEY_T _key;
+};
+
+#undef NATIVE_TSS_KEY_T
+
+/* When static allocation, you must initialize with Py_tss_NEEDS_INIT. */
+#define Py_tss_NEEDS_INIT   {0}
+#endif  /* !Py_LIMITED_API */
+
+PyAPI_FUNC(Py_tss_t *) PyThread_tss_alloc(void);
+PyAPI_FUNC(void) PyThread_tss_free(Py_tss_t *key);
+
+/* The parameter key must not be NULL. */
+PyAPI_FUNC(int) PyThread_tss_is_created(Py_tss_t *key);
+PyAPI_FUNC(int) PyThread_tss_create(Py_tss_t *key);
+PyAPI_FUNC(void) PyThread_tss_delete(Py_tss_t *key);
+PyAPI_FUNC(int) PyThread_tss_set(Py_tss_t *key, void *value);
+PyAPI_FUNC(void *) PyThread_tss_get(Py_tss_t *key);
+#endif  /* New in 3.7 */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_PYTHREAD_H */
diff --git a/marketing/include/pytime.h b/marketing/include/pytime.h
new file mode 100644
index 0000000000000000000000000000000000000000..c79eba2f5bc6f7c5135d38dc9538e60a0f46349b
--- /dev/null
+++ b/marketing/include/pytime.h
@@ -0,0 +1,246 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_PYTIME_H
+#define Py_PYTIME_H
+
+#include "pyconfig.h" /* include for defines */
+#include "object.h"
+
+/**************************************************************************
+Symbols and macros to supply platform-independent interfaces to time related
+functions and constants
+**************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* _PyTime_t: Python timestamp with subsecond precision. It can be used to
+   store a duration, and so indirectly a date (related to another date, like
+   UNIX epoch). */
+typedef int64_t _PyTime_t;
+#define _PyTime_MIN INT64_MIN
+#define _PyTime_MAX INT64_MAX
+
+typedef enum {
+    /* Round towards minus infinity (-inf).
+       For example, used to read a clock. */
+    _PyTime_ROUND_FLOOR=0,
+    /* Round towards infinity (+inf).
+       For example, used for timeout to wait "at least" N seconds. */
+    _PyTime_ROUND_CEILING=1,
+    /* Round to nearest with ties going to nearest even integer.
+       For example, used to round from a Python float. */
+    _PyTime_ROUND_HALF_EVEN=2,
+    /* Round away from zero
+       For example, used for timeout. _PyTime_ROUND_CEILING rounds
+       -1e-9 to 0 milliseconds which causes bpo-31786 issue.
+       _PyTime_ROUND_UP rounds -1e-9 to -1 millisecond which keeps
+       the timeout sign as expected. select.poll(timeout) must block
+       for negative values." */
+    _PyTime_ROUND_UP=3,
+    /* _PyTime_ROUND_TIMEOUT (an alias for _PyTime_ROUND_UP) should be
+       used for timeouts. */
+    _PyTime_ROUND_TIMEOUT = _PyTime_ROUND_UP
+} _PyTime_round_t;
+
+
+/* Convert a time_t to a PyLong. */
+PyAPI_FUNC(PyObject *) _PyLong_FromTime_t(
+    time_t sec);
+
+/* Convert a PyLong to a time_t. */
+PyAPI_FUNC(time_t) _PyLong_AsTime_t(
+    PyObject *obj);
+
+/* Convert a number of seconds, int or float, to time_t. */
+PyAPI_FUNC(int) _PyTime_ObjectToTime_t(
+    PyObject *obj,
+    time_t *sec,
+    _PyTime_round_t);
+
+/* Convert a number of seconds, int or float, to a timeval structure.
+   usec is in the range [0; 999999] and rounded towards zero.
+   For example, -1.2 is converted to (-2, 800000). */
+PyAPI_FUNC(int) _PyTime_ObjectToTimeval(
+    PyObject *obj,
+    time_t *sec,
+    long *usec,
+    _PyTime_round_t);
+
+/* Convert a number of seconds, int or float, to a timespec structure.
+   nsec is in the range [0; 999999999] and rounded towards zero.
+   For example, -1.2 is converted to (-2, 800000000). */
+PyAPI_FUNC(int) _PyTime_ObjectToTimespec(
+    PyObject *obj,
+    time_t *sec,
+    long *nsec,
+    _PyTime_round_t);
+
+
+/* Create a timestamp from a number of seconds. */
+PyAPI_FUNC(_PyTime_t) _PyTime_FromSeconds(int seconds);
+
+/* Macro to create a timestamp from a number of seconds, no integer overflow.
+   Only use the macro for small values, prefer _PyTime_FromSeconds(). */
+#define _PYTIME_FROMSECONDS(seconds) \
+            ((_PyTime_t)(seconds) * (1000 * 1000 * 1000))
+
+/* Create a timestamp from a number of nanoseconds. */
+PyAPI_FUNC(_PyTime_t) _PyTime_FromNanoseconds(_PyTime_t ns);
+
+/* Create a timestamp from nanoseconds (Python int). */
+PyAPI_FUNC(int) _PyTime_FromNanosecondsObject(_PyTime_t *t,
+    PyObject *obj);
+
+/* Convert a number of seconds (Python float or int) to a timestamp.
+   Raise an exception and return -1 on error, return 0 on success. */
+PyAPI_FUNC(int) _PyTime_FromSecondsObject(_PyTime_t *t,
+    PyObject *obj,
+    _PyTime_round_t round);
+
+/* Convert a number of milliseconds (Python float or int, 10^-3) to a timestamp.
+   Raise an exception and return -1 on error, return 0 on success. */
+PyAPI_FUNC(int) _PyTime_FromMillisecondsObject(_PyTime_t *t,
+    PyObject *obj,
+    _PyTime_round_t round);
+
+/* Convert a timestamp to a number of seconds as a C double. */
+PyAPI_FUNC(double) _PyTime_AsSecondsDouble(_PyTime_t t);
+
+/* Convert timestamp to a number of milliseconds (10^-3 seconds). */
+PyAPI_FUNC(_PyTime_t) _PyTime_AsMilliseconds(_PyTime_t t,
+    _PyTime_round_t round);
+
+/* Convert timestamp to a number of microseconds (10^-6 seconds). */
+PyAPI_FUNC(_PyTime_t) _PyTime_AsMicroseconds(_PyTime_t t,
+    _PyTime_round_t round);
+
+/* Convert timestamp to a number of nanoseconds (10^-9 seconds) as a Python int
+   object. */
+PyAPI_FUNC(PyObject *) _PyTime_AsNanosecondsObject(_PyTime_t t);
+
+/* Create a timestamp from a timeval structure.
+   Raise an exception and return -1 on overflow, return 0 on success. */
+PyAPI_FUNC(int) _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv);
+
+/* Convert a timestamp to a timeval structure (microsecond resolution).
+   tv_usec is always positive.
+   Raise an exception and return -1 if the conversion overflowed,
+   return 0 on success. */
+PyAPI_FUNC(int) _PyTime_AsTimeval(_PyTime_t t,
+    struct timeval *tv,
+    _PyTime_round_t round);
+
+/* Similar to _PyTime_AsTimeval(), but don't raise an exception on error. */
+PyAPI_FUNC(int) _PyTime_AsTimeval_noraise(_PyTime_t t,
+    struct timeval *tv,
+    _PyTime_round_t round);
+
+/* Convert a timestamp to a number of seconds (secs) and microseconds (us).
+   us is always positive. This function is similar to _PyTime_AsTimeval()
+   except that secs is always a time_t type, whereas the timeval structure
+   uses a C long for tv_sec on Windows.
+   Raise an exception and return -1 if the conversion overflowed,
+   return 0 on success. */
+PyAPI_FUNC(int) _PyTime_AsTimevalTime_t(
+    _PyTime_t t,
+    time_t *secs,
+    int *us,
+    _PyTime_round_t round);
+
+#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE)
+/* Create a timestamp from a timespec structure.
+   Raise an exception and return -1 on overflow, return 0 on success. */
+PyAPI_FUNC(int) _PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts);
+
+/* Convert a timestamp to a timespec structure (nanosecond resolution).
+   tv_nsec is always positive.
+   Raise an exception and return -1 on error, return 0 on success. */
+PyAPI_FUNC(int) _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts);
+#endif
+
+/* Compute ticks * mul / div.
+   The caller must ensure that ((div - 1) * mul) cannot overflow. */
+PyAPI_FUNC(_PyTime_t) _PyTime_MulDiv(_PyTime_t ticks,
+    _PyTime_t mul,
+    _PyTime_t div);
+
+/* Get the current time from the system clock.
+
+   The function cannot fail. _PyTime_Init() ensures that the system clock
+   works. */
+PyAPI_FUNC(_PyTime_t) _PyTime_GetSystemClock(void);
+
+/* Get the time of a monotonic clock, i.e. a clock that cannot go backwards.
+   The clock is not affected by system clock updates. The reference point of
+   the returned value is undefined, so that only the difference between the
+   results of consecutive calls is valid.
+
+   The function cannot fail. _PyTime_Init() ensures that a monotonic clock
+   is available and works. */
+PyAPI_FUNC(_PyTime_t) _PyTime_GetMonotonicClock(void);
+
+
+/* Structure used by time.get_clock_info() */
+typedef struct {
+    const char *implementation;
+    int monotonic;
+    int adjustable;
+    double resolution;
+} _Py_clock_info_t;
+
+/* Get the current time from the system clock.
+ * Fill clock information if info is not NULL.
+ * Raise an exception and return -1 on error, return 0 on success.
+ */
+PyAPI_FUNC(int) _PyTime_GetSystemClockWithInfo(
+    _PyTime_t *t,
+    _Py_clock_info_t *info);
+
+/* Get the time of a monotonic clock, i.e. a clock that cannot go backwards.
+   The clock is not affected by system clock updates. The reference point of
+   the returned value is undefined, so that only the difference between the
+   results of consecutive calls is valid.
+
+   Fill info (if set) with information of the function used to get the time.
+
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int) _PyTime_GetMonotonicClockWithInfo(
+    _PyTime_t *t,
+    _Py_clock_info_t *info);
+
+
+/* Initialize time.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int) _PyTime_Init(void);
+
+/* Converts a timestamp to the Gregorian time, using the local time zone.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int) _PyTime_localtime(time_t t, struct tm *tm);
+
+/* Converts a timestamp to the Gregorian time, assuming UTC.
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int) _PyTime_gmtime(time_t t, struct tm *tm);
+
+/* Get the performance counter: clock with the highest available resolution to
+   measure a short duration.
+
+   The function cannot fail. _PyTime_Init() ensures that the system clock
+   works. */
+PyAPI_FUNC(_PyTime_t) _PyTime_GetPerfCounter(void);
+
+/* Get the performance counter: clock with the highest available resolution to
+   measure a short duration.
+
+   Fill info (if set) with information of the function used to get the time.
+
+   Return 0 on success, raise an exception and return -1 on error. */
+PyAPI_FUNC(int) _PyTime_GetPerfCounterWithInfo(
+    _PyTime_t *t,
+    _Py_clock_info_t *info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* Py_PYTIME_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/rangeobject.h b/marketing/include/rangeobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6af8473f9e8d33f011c6c42d6350fa00ca6ac3d
--- /dev/null
+++ b/marketing/include/rangeobject.h
@@ -0,0 +1,27 @@
+
+/* Range object interface */
+
+#ifndef Py_RANGEOBJECT_H
+#define Py_RANGEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+A range object represents an integer range.  This is an immutable object;
+a range cannot change its value after creation.
+
+Range objects behave like the corresponding tuple objects except that
+they are represented by a start, stop, and step datamembers.
+*/
+
+PyAPI_DATA(PyTypeObject) PyRange_Type;
+PyAPI_DATA(PyTypeObject) PyRangeIter_Type;
+PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type;
+
+#define PyRange_Check(op) Py_IS_TYPE(op, &PyRange_Type)
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_RANGEOBJECT_H */
diff --git a/marketing/include/setobject.h b/marketing/include/setobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..119619ebe72994be28bc58d92fb3df81e849e0b9
--- /dev/null
+++ b/marketing/include/setobject.h
@@ -0,0 +1,107 @@
+/* Set object interface */
+
+#ifndef Py_SETOBJECT_H
+#define Py_SETOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+
+/* There are three kinds of entries in the table:
+
+1. Unused:  key == NULL and hash == 0
+2. Dummy:   key == dummy and hash == -1
+3. Active:  key != NULL and key != dummy and hash != -1
+
+The hash field of Unused slots is always zero.
+
+The hash field of Dummy slots are set to -1
+meaning that dummy entries can be detected by
+either entry->key==dummy or by entry->hash==-1.
+*/
+
+#define PySet_MINSIZE 8
+
+typedef struct {
+    PyObject *key;
+    Py_hash_t hash;             /* Cached hash code of the key */
+} setentry;
+
+/* The SetObject data structure is shared by set and frozenset objects.
+
+Invariant for sets:
+ - hash is -1
+
+Invariants for frozensets:
+ - data is immutable.
+ - hash is the hash of the frozenset or -1 if not computed yet.
+
+*/
+
+typedef struct {
+    PyObject_HEAD
+
+    Py_ssize_t fill;            /* Number active and dummy entries*/
+    Py_ssize_t used;            /* Number active entries */
+
+    /* The table contains mask + 1 slots, and that's a power of 2.
+     * We store the mask instead of the size because the mask is more
+     * frequently needed.
+     */
+    Py_ssize_t mask;
+
+    /* The table points to a fixed-size smalltable for small tables
+     * or to additional malloc'ed memory for bigger tables.
+     * The table pointer is never NULL which saves us from repeated
+     * runtime null-tests.
+     */
+    setentry *table;
+    Py_hash_t hash;             /* Only used by frozenset objects */
+    Py_ssize_t finger;          /* Search finger for pop() */
+
+    setentry smalltable[PySet_MINSIZE];
+    PyObject *weakreflist;      /* List of weak references */
+} PySetObject;
+
+#define PySet_GET_SIZE(so) (assert(PyAnySet_Check(so)),(((PySetObject *)(so))->used))
+
+PyAPI_DATA(PyObject *) _PySet_Dummy;
+
+PyAPI_FUNC(int) _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, Py_hash_t *hash);
+PyAPI_FUNC(int) _PySet_Update(PyObject *set, PyObject *iterable);
+
+#endif /* Section excluded by Py_LIMITED_API */
+
+PyAPI_DATA(PyTypeObject) PySet_Type;
+PyAPI_DATA(PyTypeObject) PyFrozenSet_Type;
+PyAPI_DATA(PyTypeObject) PySetIter_Type;
+
+PyAPI_FUNC(PyObject *) PySet_New(PyObject *);
+PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *);
+
+PyAPI_FUNC(int) PySet_Add(PyObject *set, PyObject *key);
+PyAPI_FUNC(int) PySet_Clear(PyObject *set);
+PyAPI_FUNC(int) PySet_Contains(PyObject *anyset, PyObject *key);
+PyAPI_FUNC(int) PySet_Discard(PyObject *set, PyObject *key);
+PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set);
+PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject *anyset);
+
+#define PyFrozenSet_CheckExact(ob) Py_IS_TYPE(ob, &PyFrozenSet_Type)
+#define PyAnySet_CheckExact(ob) \
+    (Py_IS_TYPE(ob, &PySet_Type) || Py_IS_TYPE(ob, &PyFrozenSet_Type))
+#define PyAnySet_Check(ob) \
+    (Py_IS_TYPE(ob, &PySet_Type) || Py_IS_TYPE(ob, &PyFrozenSet_Type) || \
+      PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
+      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
+#define PySet_Check(ob) \
+    (Py_IS_TYPE(ob, &PySet_Type) || \
+    PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
+#define   PyFrozenSet_Check(ob) \
+    (Py_IS_TYPE(ob, &PyFrozenSet_Type) || \
+      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_SETOBJECT_H */
diff --git a/marketing/include/sliceobject.h b/marketing/include/sliceobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c889508b4b495b56df2fc034f6f6ad5baebba89
--- /dev/null
+++ b/marketing/include/sliceobject.h
@@ -0,0 +1,65 @@
+#ifndef Py_SLICEOBJECT_H
+#define Py_SLICEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The unique ellipsis object "..." */
+
+PyAPI_DATA(PyObject) _Py_EllipsisObject; /* Don't use this directly */
+
+#define Py_Ellipsis (&_Py_EllipsisObject)
+
+/* Slice object interface */
+
+/*
+
+A slice object containing start, stop, and step data members (the
+names are from range).  After much talk with Guido, it was decided to
+let these be any arbitrary python type.  Py_None stands for omitted values.
+*/
+#ifndef Py_LIMITED_API
+typedef struct {
+    PyObject_HEAD
+    PyObject *start, *stop, *step;      /* not NULL */
+} PySliceObject;
+#endif
+
+PyAPI_DATA(PyTypeObject) PySlice_Type;
+PyAPI_DATA(PyTypeObject) PyEllipsis_Type;
+
+#define PySlice_Check(op) Py_IS_TYPE(op, &PySlice_Type)
+
+PyAPI_FUNC(PyObject *) PySlice_New(PyObject* start, PyObject* stop,
+                                  PyObject* step);
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject *) _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop);
+PyAPI_FUNC(int) _PySlice_GetLongIndices(PySliceObject *self, PyObject *length,
+                                 PyObject **start_ptr, PyObject **stop_ptr,
+                                 PyObject **step_ptr);
+#endif
+PyAPI_FUNC(int) PySlice_GetIndices(PyObject *r, Py_ssize_t length,
+                                  Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
+Py_DEPRECATED(3.7)
+PyAPI_FUNC(int) PySlice_GetIndicesEx(PyObject *r, Py_ssize_t length,
+                                     Py_ssize_t *start, Py_ssize_t *stop,
+                                     Py_ssize_t *step,
+                                     Py_ssize_t *slicelength);
+
+#if !defined(Py_LIMITED_API) || (Py_LIMITED_API+0 >= 0x03050400 && Py_LIMITED_API+0 < 0x03060000) || Py_LIMITED_API+0 >= 0x03060100
+#define PySlice_GetIndicesEx(slice, length, start, stop, step, slicelen) (  \
+    PySlice_Unpack((slice), (start), (stop), (step)) < 0 ?                  \
+    ((*(slicelen) = 0), -1) :                                               \
+    ((*(slicelen) = PySlice_AdjustIndices((length), (start), (stop), *(step))), \
+     0))
+PyAPI_FUNC(int) PySlice_Unpack(PyObject *slice,
+                               Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
+PyAPI_FUNC(Py_ssize_t) PySlice_AdjustIndices(Py_ssize_t length,
+                                             Py_ssize_t *start, Py_ssize_t *stop,
+                                             Py_ssize_t step);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_SLICEOBJECT_H */
diff --git a/marketing/include/structmember.h b/marketing/include/structmember.h
new file mode 100644
index 0000000000000000000000000000000000000000..b54f7081f458dd9c33a524874b4b3e90c3bbf954
--- /dev/null
+++ b/marketing/include/structmember.h
@@ -0,0 +1,74 @@
+#ifndef Py_STRUCTMEMBER_H
+#define Py_STRUCTMEMBER_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Interface to map C struct members to Python object attributes */
+
+#include  /* For offsetof */
+
+/* An array of PyMemberDef structures defines the name, type and offset
+   of selected members of a C structure.  These can be read by
+   PyMember_GetOne() and set by PyMember_SetOne() (except if their READONLY
+   flag is set).  The array must be terminated with an entry whose name
+   pointer is NULL. */
+
+typedef struct PyMemberDef {
+    const char *name;
+    int type;
+    Py_ssize_t offset;
+    int flags;
+    const char *doc;
+} PyMemberDef;
+
+/* Types */
+#define T_SHORT     0
+#define T_INT       1
+#define T_LONG      2
+#define T_FLOAT     3
+#define T_DOUBLE    4
+#define T_STRING    5
+#define T_OBJECT    6
+/* XXX the ordering here is weird for binary compatibility */
+#define T_CHAR      7   /* 1-character string */
+#define T_BYTE      8   /* 8-bit signed int */
+/* unsigned variants: */
+#define T_UBYTE     9
+#define T_USHORT    10
+#define T_UINT      11
+#define T_ULONG     12
+
+/* Added by Jack: strings contained in the structure */
+#define T_STRING_INPLACE    13
+
+/* Added by Lillo: bools contained in the structure (assumed char) */
+#define T_BOOL      14
+
+#define T_OBJECT_EX 16  /* Like T_OBJECT, but raises AttributeError
+                           when the value is NULL, instead of
+                           converting to None. */
+#define T_LONGLONG      17
+#define T_ULONGLONG     18
+
+#define T_PYSSIZET      19      /* Py_ssize_t */
+#define T_NONE          20      /* Value is always None */
+
+
+/* Flags */
+#define READONLY            1
+#define READ_RESTRICTED     2
+#define PY_WRITE_RESTRICTED 4
+#define RESTRICTED          (READ_RESTRICTED | PY_WRITE_RESTRICTED)
+
+
+/* Current API, use this */
+PyAPI_FUNC(PyObject *) PyMember_GetOne(const char *, struct PyMemberDef *);
+PyAPI_FUNC(int) PyMember_SetOne(char *, struct PyMemberDef *, PyObject *);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_STRUCTMEMBER_H */
diff --git a/marketing/include/structseq.h b/marketing/include/structseq.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f51c89163a4e17ef188001de6d9fa53d70b97ad
--- /dev/null
+++ b/marketing/include/structseq.h
@@ -0,0 +1,49 @@
+
+/* Named tuple object interface */
+
+#ifndef Py_STRUCTSEQ_H
+#define Py_STRUCTSEQ_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PyStructSequence_Field {
+    const char *name;
+    const char *doc;
+} PyStructSequence_Field;
+
+typedef struct PyStructSequence_Desc {
+    const char *name;
+    const char *doc;
+    struct PyStructSequence_Field *fields;
+    int n_in_sequence;
+} PyStructSequence_Desc;
+
+extern const char * const PyStructSequence_UnnamedField;
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type,
+                                           PyStructSequence_Desc *desc);
+PyAPI_FUNC(int) PyStructSequence_InitType2(PyTypeObject *type,
+                                           PyStructSequence_Desc *desc);
+#endif
+PyAPI_FUNC(PyTypeObject*) PyStructSequence_NewType(PyStructSequence_Desc *desc);
+
+PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type);
+
+#ifndef Py_LIMITED_API
+typedef PyTupleObject PyStructSequence;
+
+/* Macro, *only* to be used to fill in brand new objects */
+#define PyStructSequence_SET_ITEM(op, i, v) PyTuple_SET_ITEM(op, i, v)
+
+#define PyStructSequence_GET_ITEM(op, i) PyTuple_GET_ITEM(op, i)
+#endif
+
+PyAPI_FUNC(void) PyStructSequence_SetItem(PyObject*, Py_ssize_t, PyObject*);
+PyAPI_FUNC(PyObject*) PyStructSequence_GetItem(PyObject*, Py_ssize_t);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_STRUCTSEQ_H */
diff --git a/marketing/include/symtable.h b/marketing/include/symtable.h
new file mode 100644
index 0000000000000000000000000000000000000000..abd19a7923e1ba3186231e9e83826f633198cc50
--- /dev/null
+++ b/marketing/include/symtable.h
@@ -0,0 +1,123 @@
+#ifndef Py_LIMITED_API
+#ifndef Py_SYMTABLE_H
+#define Py_SYMTABLE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "Python-ast.h"   /* mod_ty */
+
+/* XXX(ncoghlan): This is a weird mix of public names and interpreter internal
+ *                names.
+ */
+
+typedef enum _block_type { FunctionBlock, ClassBlock, ModuleBlock }
+    _Py_block_ty;
+
+struct _symtable_entry;
+
+struct symtable {
+    PyObject *st_filename;          /* name of file being compiled,
+                                       decoded from the filesystem encoding */
+    struct _symtable_entry *st_cur; /* current symbol table entry */
+    struct _symtable_entry *st_top; /* symbol table entry for module */
+    PyObject *st_blocks;            /* dict: map AST node addresses
+                                     *       to symbol table entries */
+    PyObject *st_stack;             /* list: stack of namespace info */
+    PyObject *st_global;            /* borrowed ref to st_top->ste_symbols */
+    int st_nblocks;                 /* number of blocks used. kept for
+                                       consistency with the corresponding
+                                       compiler structure */
+    PyObject *st_private;           /* name of current class or NULL */
+    PyFutureFeatures *st_future;    /* module's future features that affect
+                                       the symbol table */
+    int recursion_depth;            /* current recursion depth */
+    int recursion_limit;            /* recursion limit */
+};
+
+typedef struct _symtable_entry {
+    PyObject_HEAD
+    PyObject *ste_id;        /* int: key in ste_table->st_blocks */
+    PyObject *ste_symbols;   /* dict: variable names to flags */
+    PyObject *ste_name;      /* string: name of current block */
+    PyObject *ste_varnames;  /* list of function parameters */
+    PyObject *ste_children;  /* list of child blocks */
+    PyObject *ste_directives;/* locations of global and nonlocal statements */
+    _Py_block_ty ste_type;   /* module, class, or function */
+    int ste_nested;      /* true if block is nested */
+    unsigned ste_free : 1;        /* true if block has free variables */
+    unsigned ste_child_free : 1;  /* true if a child block has free vars,
+                                     including free refs to globals */
+    unsigned ste_generator : 1;   /* true if namespace is a generator */
+    unsigned ste_coroutine : 1;   /* true if namespace is a coroutine */
+    unsigned ste_comprehension : 1; /* true if namespace is a list comprehension */
+    unsigned ste_varargs : 1;     /* true if block has varargs */
+    unsigned ste_varkeywords : 1; /* true if block has varkeywords */
+    unsigned ste_returns_value : 1;  /* true if namespace uses return with
+                                        an argument */
+    unsigned ste_needs_class_closure : 1; /* for class scopes, true if a
+                                             closure over __class__
+                                             should be created */
+    unsigned ste_comp_iter_target : 1; /* true if visiting comprehension target */
+    int ste_comp_iter_expr; /* non-zero if visiting a comprehension range expression */
+    int ste_lineno;          /* first line of block */
+    int ste_col_offset;      /* offset of first line of block */
+    int ste_opt_lineno;      /* lineno of last exec or import * */
+    int ste_opt_col_offset;  /* offset of last exec or import * */
+    struct symtable *ste_table;
+} PySTEntryObject;
+
+PyAPI_DATA(PyTypeObject) PySTEntry_Type;
+
+#define PySTEntry_Check(op) Py_IS_TYPE(op, &PySTEntry_Type)
+
+PyAPI_FUNC(int) PyST_GetScope(PySTEntryObject *, PyObject *);
+
+PyAPI_FUNC(struct symtable *) PySymtable_Build(
+    mod_ty mod,
+    const char *filename,       /* decoded from the filesystem encoding */
+    PyFutureFeatures *future);
+PyAPI_FUNC(struct symtable *) PySymtable_BuildObject(
+    mod_ty mod,
+    PyObject *filename,
+    PyFutureFeatures *future);
+PyAPI_FUNC(PySTEntryObject *) PySymtable_Lookup(struct symtable *, void *);
+
+PyAPI_FUNC(void) PySymtable_Free(struct symtable *);
+
+/* Flags for def-use information */
+
+#define DEF_GLOBAL 1           /* global stmt */
+#define DEF_LOCAL 2            /* assignment in code block */
+#define DEF_PARAM 2<<1         /* formal parameter */
+#define DEF_NONLOCAL 2<<2      /* nonlocal stmt */
+#define USE 2<<3               /* name is used */
+#define DEF_FREE 2<<4          /* name used but not defined in nested block */
+#define DEF_FREE_CLASS 2<<5    /* free variable from class's method */
+#define DEF_IMPORT 2<<6        /* assignment occurred via import */
+#define DEF_ANNOT 2<<7         /* this name is annotated */
+#define DEF_COMP_ITER 2<<8     /* this name is a comprehension iteration variable */
+
+#define DEF_BOUND (DEF_LOCAL | DEF_PARAM | DEF_IMPORT)
+
+/* GLOBAL_EXPLICIT and GLOBAL_IMPLICIT are used internally by the symbol
+   table.  GLOBAL is returned from PyST_GetScope() for either of them.
+   It is stored in ste_symbols at bits 12-15.
+*/
+#define SCOPE_OFFSET 11
+#define SCOPE_MASK (DEF_GLOBAL | DEF_LOCAL | DEF_PARAM | DEF_NONLOCAL)
+
+#define LOCAL 1
+#define GLOBAL_EXPLICIT 2
+#define GLOBAL_IMPLICIT 3
+#define FREE 4
+#define CELL 5
+
+#define GENERATOR 1
+#define GENERATOR_EXPRESSION 2
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_SYMTABLE_H */
+#endif /* !Py_LIMITED_API */
diff --git a/marketing/include/sysmodule.h b/marketing/include/sysmodule.h
new file mode 100644
index 0000000000000000000000000000000000000000..670e5d283f770197b30bb691162195a1ffea9709
--- /dev/null
+++ b/marketing/include/sysmodule.h
@@ -0,0 +1,41 @@
+
+/* System module interface */
+
+#ifndef Py_SYSMODULE_H
+#define Py_SYSMODULE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(PyObject *) PySys_GetObject(const char *);
+PyAPI_FUNC(int) PySys_SetObject(const char *, PyObject *);
+
+PyAPI_FUNC(void) PySys_SetArgv(int, wchar_t **);
+PyAPI_FUNC(void) PySys_SetArgvEx(int, wchar_t **, int);
+PyAPI_FUNC(void) PySys_SetPath(const wchar_t *);
+
+PyAPI_FUNC(void) PySys_WriteStdout(const char *format, ...)
+                 Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
+PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...)
+                 Py_GCC_ATTRIBUTE((format(printf, 1, 2)));
+PyAPI_FUNC(void) PySys_FormatStdout(const char *format, ...);
+PyAPI_FUNC(void) PySys_FormatStderr(const char *format, ...);
+
+PyAPI_FUNC(void) PySys_ResetWarnOptions(void);
+PyAPI_FUNC(void) PySys_AddWarnOption(const wchar_t *);
+PyAPI_FUNC(void) PySys_AddWarnOptionUnicode(PyObject *);
+PyAPI_FUNC(int) PySys_HasWarnOptions(void);
+
+PyAPI_FUNC(void) PySys_AddXOption(const wchar_t *);
+PyAPI_FUNC(PyObject *) PySys_GetXOptions(void);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_SYSMODULE_H
+#  include  "cpython/sysmodule.h"
+#  undef Py_CPYTHON_SYSMODULE_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_SYSMODULE_H */
diff --git a/marketing/include/token.h b/marketing/include/token.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b8a3aae0746747ed90a86e435ec0594390e0404
--- /dev/null
+++ b/marketing/include/token.h
@@ -0,0 +1,96 @@
+/* Auto-generated by Tools/scripts/generate_token.py */
+
+/* Token types */
+#ifndef Py_LIMITED_API
+#ifndef Py_TOKEN_H
+#define Py_TOKEN_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#undef TILDE   /* Prevent clash of our definition with system macro. Ex AIX, ioctl.h */
+
+#define ENDMARKER       0
+#define NAME            1
+#define NUMBER          2
+#define STRING          3
+#define NEWLINE         4
+#define INDENT          5
+#define DEDENT          6
+#define LPAR            7
+#define RPAR            8
+#define LSQB            9
+#define RSQB            10
+#define COLON           11
+#define COMMA           12
+#define SEMI            13
+#define PLUS            14
+#define MINUS           15
+#define STAR            16
+#define SLASH           17
+#define VBAR            18
+#define AMPER           19
+#define LESS            20
+#define GREATER         21
+#define EQUAL           22
+#define DOT             23
+#define PERCENT         24
+#define LBRACE          25
+#define RBRACE          26
+#define EQEQUAL         27
+#define NOTEQUAL        28
+#define LESSEQUAL       29
+#define GREATEREQUAL    30
+#define TILDE           31
+#define CIRCUMFLEX      32
+#define LEFTSHIFT       33
+#define RIGHTSHIFT      34
+#define DOUBLESTAR      35
+#define PLUSEQUAL       36
+#define MINEQUAL        37
+#define STAREQUAL       38
+#define SLASHEQUAL      39
+#define PERCENTEQUAL    40
+#define AMPEREQUAL      41
+#define VBAREQUAL       42
+#define CIRCUMFLEXEQUAL 43
+#define LEFTSHIFTEQUAL  44
+#define RIGHTSHIFTEQUAL 45
+#define DOUBLESTAREQUAL 46
+#define DOUBLESLASH     47
+#define DOUBLESLASHEQUAL 48
+#define AT              49
+#define ATEQUAL         50
+#define RARROW          51
+#define ELLIPSIS        52
+#define COLONEQUAL      53
+#define OP              54
+#define AWAIT           55
+#define ASYNC           56
+#define TYPE_IGNORE     57
+#define TYPE_COMMENT    58
+#define ERRORTOKEN      59
+#define N_TOKENS        63
+#define NT_OFFSET       256
+
+/* Special definitions for cooperation with parser */
+
+#define ISTERMINAL(x)           ((x) < NT_OFFSET)
+#define ISNONTERMINAL(x)        ((x) >= NT_OFFSET)
+#define ISEOF(x)                ((x) == ENDMARKER)
+#define ISWHITESPACE(x)         ((x) == ENDMARKER || \
+                                 (x) == NEWLINE   || \
+                                 (x) == INDENT    || \
+                                 (x) == DEDENT)
+
+
+PyAPI_DATA(const char * const) _PyParser_TokenNames[]; /* Token names */
+PyAPI_FUNC(int) PyToken_OneChar(int);
+PyAPI_FUNC(int) PyToken_TwoChars(int, int);
+PyAPI_FUNC(int) PyToken_ThreeChars(int, int, int);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_TOKEN_H */
+#endif /* Py_LIMITED_API */
diff --git a/marketing/include/traceback.h b/marketing/include/traceback.h
new file mode 100644
index 0000000000000000000000000000000000000000..781e5a6eec4edd4c199079aa9f25d8c05082b3f2
--- /dev/null
+++ b/marketing/include/traceback.h
@@ -0,0 +1,26 @@
+#ifndef Py_TRACEBACK_H
+#define Py_TRACEBACK_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Traceback interface */
+
+PyAPI_FUNC(int) PyTraceBack_Here(PyFrameObject *);
+PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *);
+
+/* Reveal traceback type so we can typecheck traceback objects */
+PyAPI_DATA(PyTypeObject) PyTraceBack_Type;
+#define PyTraceBack_Check(v) Py_IS_TYPE(v, &PyTraceBack_Type)
+
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_TRACEBACK_H
+#  include  "cpython/traceback.h"
+#  undef Py_CPYTHON_TRACEBACK_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_TRACEBACK_H */
diff --git a/marketing/include/tracemalloc.h b/marketing/include/tracemalloc.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd14217c199c3cb212aa8253d1c32c0e53325b40
--- /dev/null
+++ b/marketing/include/tracemalloc.h
@@ -0,0 +1,38 @@
+#ifndef Py_TRACEMALLOC_H
+#define Py_TRACEMALLOC_H
+
+#ifndef Py_LIMITED_API
+/* Track an allocated memory block in the tracemalloc module.
+   Return 0 on success, return -1 on error (failed to allocate memory to store
+   the trace).
+
+   Return -2 if tracemalloc is disabled.
+
+   If memory block is already tracked, update the existing trace. */
+PyAPI_FUNC(int) PyTraceMalloc_Track(
+    unsigned int domain,
+    uintptr_t ptr,
+    size_t size);
+
+/* Untrack an allocated memory block in the tracemalloc module.
+   Do nothing if the block was not tracked.
+
+   Return -2 if tracemalloc is disabled, otherwise return 0. */
+PyAPI_FUNC(int) PyTraceMalloc_Untrack(
+    unsigned int domain,
+    uintptr_t ptr);
+
+/* Get the traceback where a memory block was allocated.
+
+   Return a tuple of (filename: str, lineno: int) tuples.
+
+   Return None if the tracemalloc module is disabled or if the memory block
+   is not tracked by tracemalloc.
+
+   Raise an exception and return NULL on error. */
+PyAPI_FUNC(PyObject*) _PyTraceMalloc_GetTraceback(
+    unsigned int domain,
+    uintptr_t ptr);
+#endif
+
+#endif /* !Py_TRACEMALLOC_H */
diff --git a/marketing/include/tupleobject.h b/marketing/include/tupleobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..e796a320192c204466ffca35d27a32fd3d064f5c
--- /dev/null
+++ b/marketing/include/tupleobject.h
@@ -0,0 +1,46 @@
+/* Tuple object interface */
+
+#ifndef Py_TUPLEOBJECT_H
+#define Py_TUPLEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+Another generally useful object type is a tuple of object pointers.
+For Python, this is an immutable type.  C code can change the tuple items
+(but not their number), and even use tuples as general-purpose arrays of
+object references, but in general only brand new tuples should be mutated,
+not ones that might already have been exposed to Python code.
+
+*** WARNING *** PyTuple_SetItem does not increment the new item's reference
+count, but does decrement the reference count of the item it replaces,
+if not nil.  It does *decrement* the reference count if it is *not*
+inserted in the tuple.  Similarly, PyTuple_GetItem does not increment the
+returned item's reference count.
+*/
+
+PyAPI_DATA(PyTypeObject) PyTuple_Type;
+PyAPI_DATA(PyTypeObject) PyTupleIter_Type;
+
+#define PyTuple_Check(op) \
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS)
+#define PyTuple_CheckExact(op) Py_IS_TYPE(op, &PyTuple_Type)
+
+PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size);
+PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *);
+PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, Py_ssize_t);
+PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *);
+PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
+PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...);
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_TUPLEOBJECT_H
+#  include  "cpython/tupleobject.h"
+#  undef Py_CPYTHON_TUPLEOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_TUPLEOBJECT_H */
diff --git a/marketing/include/typeslots.h b/marketing/include/typeslots.h
new file mode 100644
index 0000000000000000000000000000000000000000..64f6fff51444937d70c3d2af414af0bfa040cbee
--- /dev/null
+++ b/marketing/include/typeslots.h
@@ -0,0 +1,90 @@
+/* Do not renumber the file; these numbers are part of the stable ABI. */
+#if defined(Py_LIMITED_API)
+/* Disabled, see #10181 */
+#undef Py_bf_getbuffer
+#undef Py_bf_releasebuffer
+#else
+#define Py_bf_getbuffer 1
+#define Py_bf_releasebuffer 2
+#endif
+#define Py_mp_ass_subscript 3
+#define Py_mp_length 4
+#define Py_mp_subscript 5
+#define Py_nb_absolute 6
+#define Py_nb_add 7
+#define Py_nb_and 8
+#define Py_nb_bool 9
+#define Py_nb_divmod 10
+#define Py_nb_float 11
+#define Py_nb_floor_divide 12
+#define Py_nb_index 13
+#define Py_nb_inplace_add 14
+#define Py_nb_inplace_and 15
+#define Py_nb_inplace_floor_divide 16
+#define Py_nb_inplace_lshift 17
+#define Py_nb_inplace_multiply 18
+#define Py_nb_inplace_or 19
+#define Py_nb_inplace_power 20
+#define Py_nb_inplace_remainder 21
+#define Py_nb_inplace_rshift 22
+#define Py_nb_inplace_subtract 23
+#define Py_nb_inplace_true_divide 24
+#define Py_nb_inplace_xor 25
+#define Py_nb_int 26
+#define Py_nb_invert 27
+#define Py_nb_lshift 28
+#define Py_nb_multiply 29
+#define Py_nb_negative 30
+#define Py_nb_or 31
+#define Py_nb_positive 32
+#define Py_nb_power 33
+#define Py_nb_remainder 34
+#define Py_nb_rshift 35
+#define Py_nb_subtract 36
+#define Py_nb_true_divide 37
+#define Py_nb_xor 38
+#define Py_sq_ass_item 39
+#define Py_sq_concat 40
+#define Py_sq_contains 41
+#define Py_sq_inplace_concat 42
+#define Py_sq_inplace_repeat 43
+#define Py_sq_item 44
+#define Py_sq_length 45
+#define Py_sq_repeat 46
+#define Py_tp_alloc 47
+#define Py_tp_base 48
+#define Py_tp_bases 49
+#define Py_tp_call 50
+#define Py_tp_clear 51
+#define Py_tp_dealloc 52
+#define Py_tp_del 53
+#define Py_tp_descr_get 54
+#define Py_tp_descr_set 55
+#define Py_tp_doc 56
+#define Py_tp_getattr 57
+#define Py_tp_getattro 58
+#define Py_tp_hash 59
+#define Py_tp_init 60
+#define Py_tp_is_gc 61
+#define Py_tp_iter 62
+#define Py_tp_iternext 63
+#define Py_tp_methods 64
+#define Py_tp_new 65
+#define Py_tp_repr 66
+#define Py_tp_richcompare 67
+#define Py_tp_setattr 68
+#define Py_tp_setattro 69
+#define Py_tp_str 70
+#define Py_tp_traverse 71
+#define Py_tp_members 72
+#define Py_tp_getset 73
+#define Py_tp_free 74
+#define Py_nb_matrix_multiply 75
+#define Py_nb_inplace_matrix_multiply 76
+#define Py_am_await 77
+#define Py_am_aiter 78
+#define Py_am_anext 79
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+/* New in 3.5 */
+#define Py_tp_finalize 80
+#endif
diff --git a/marketing/include/ucnhash.h b/marketing/include/ucnhash.h
new file mode 100644
index 0000000000000000000000000000000000000000..45362e997dfa118f30d2c5bb4406105f744ce53b
--- /dev/null
+++ b/marketing/include/ucnhash.h
@@ -0,0 +1,36 @@
+/* Unicode name database interface */
+#ifndef Py_LIMITED_API
+#ifndef Py_UCNHASH_H
+#define Py_UCNHASH_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* revised ucnhash CAPI interface (exported through a "wrapper") */
+
+#define PyUnicodeData_CAPSULE_NAME "unicodedata.ucnhash_CAPI"
+
+typedef struct {
+
+    /* Size of this struct */
+    int size;
+
+    /* Get name for a given character code.  Returns non-zero if
+       success, zero if not.  Does not set Python exceptions.
+       If self is NULL, data come from the default version of the database.
+       If it is not NULL, it should be a unicodedata.ucd_X_Y_Z object */
+    int (*getname)(PyObject *self, Py_UCS4 code, char* buffer, int buflen,
+                   int with_alias_and_seq);
+
+    /* Get character code for a given name.  Same error handling
+       as for getname. */
+    int (*getcode)(PyObject *self, const char* name, int namelen, Py_UCS4* code,
+                   int with_named_seq);
+
+} _PyUnicode_Name_CAPI;
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_UCNHASH_H */
+#endif /* !Py_LIMITED_API */
diff --git a/marketing/include/unicodeobject.h b/marketing/include/unicodeobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..500ce242e9f0e850f483695463701aed7d3cce14
--- /dev/null
+++ b/marketing/include/unicodeobject.h
@@ -0,0 +1,1033 @@
+#ifndef Py_UNICODEOBJECT_H
+#define Py_UNICODEOBJECT_H
+
+#include 
+
+/*
+
+Unicode implementation based on original code by Fredrik Lundh,
+modified by Marc-Andre Lemburg (mal@lemburg.com) according to the
+Unicode Integration Proposal. (See
+http://www.egenix.com/files/python/unicode-proposal.txt).
+
+Copyright (c) Corporation for National Research Initiatives.
+
+
+ Original header:
+ --------------------------------------------------------------------
+
+ * Yet another Unicode string type for Python.  This type supports the
+ * 16-bit Basic Multilingual Plane (BMP) only.
+ *
+ * Written by Fredrik Lundh, January 1999.
+ *
+ * Copyright (c) 1999 by Secret Labs AB.
+ * Copyright (c) 1999 by Fredrik Lundh.
+ *
+ * fredrik@pythonware.com
+ * http://www.pythonware.com
+ *
+ * --------------------------------------------------------------------
+ * This Unicode String Type is
+ *
+ * Copyright (c) 1999 by Secret Labs AB
+ * Copyright (c) 1999 by Fredrik Lundh
+ *
+ * By obtaining, using, and/or copying this software and/or its
+ * associated documentation, you agree that you have read, understood,
+ * and will comply with the following terms and conditions:
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * associated documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appears in all
+ * copies, and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of Secret Labs
+ * AB or the author not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission.
+ *
+ * SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ * -------------------------------------------------------------------- */
+
+#include 
+
+/* === Internal API ======================================================= */
+
+/* --- Internal Unicode Format -------------------------------------------- */
+
+/* Python 3.x requires unicode */
+#define Py_USING_UNICODE
+
+#ifndef SIZEOF_WCHAR_T
+#error Must define SIZEOF_WCHAR_T
+#endif
+
+#define Py_UNICODE_SIZE SIZEOF_WCHAR_T
+
+/* If wchar_t can be used for UCS-4 storage, set Py_UNICODE_WIDE.
+   Otherwise, Unicode strings are stored as UCS-2 (with limited support
+   for UTF-16) */
+
+#if Py_UNICODE_SIZE >= 4
+#define Py_UNICODE_WIDE
+#endif
+
+/* Set these flags if the platform has "wchar.h" and the
+   wchar_t type is a 16-bit unsigned type */
+/* #define HAVE_WCHAR_H */
+/* #define HAVE_USABLE_WCHAR_T */
+
+/* If the compiler provides a wchar_t type we try to support it
+   through the interface functions PyUnicode_FromWideChar(),
+   PyUnicode_AsWideChar() and PyUnicode_AsWideCharString(). */
+
+#ifdef HAVE_USABLE_WCHAR_T
+# ifndef HAVE_WCHAR_H
+#  define HAVE_WCHAR_H
+# endif
+#endif
+
+#ifdef HAVE_WCHAR_H
+#  include 
+#endif
+
+/* Py_UCS4 and Py_UCS2 are typedefs for the respective
+   unicode representations. */
+typedef uint32_t Py_UCS4;
+typedef uint16_t Py_UCS2;
+typedef uint8_t Py_UCS1;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+PyAPI_DATA(PyTypeObject) PyUnicode_Type;
+PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type;
+
+#define PyUnicode_Check(op) \
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS)
+#define PyUnicode_CheckExact(op) Py_IS_TYPE(op, &PyUnicode_Type)
+
+/* --- Constants ---------------------------------------------------------- */
+
+/* This Unicode character will be used as replacement character during
+   decoding if the errors argument is set to "replace". Note: the
+   Unicode character U+FFFD is the official REPLACEMENT CHARACTER in
+   Unicode 3.0. */
+
+#define Py_UNICODE_REPLACEMENT_CHARACTER ((Py_UCS4) 0xFFFD)
+
+/* === Public API ========================================================= */
+
+/* Similar to PyUnicode_FromUnicode(), but u points to UTF-8 encoded bytes */
+PyAPI_FUNC(PyObject*) PyUnicode_FromStringAndSize(
+    const char *u,             /* UTF-8 encoded string */
+    Py_ssize_t size            /* size of buffer */
+    );
+
+/* Similar to PyUnicode_FromUnicode(), but u points to null-terminated
+   UTF-8 encoded bytes.  The size is determined with strlen(). */
+PyAPI_FUNC(PyObject*) PyUnicode_FromString(
+    const char *u              /* UTF-8 encoded string */
+    );
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject*) PyUnicode_Substring(
+    PyObject *str,
+    Py_ssize_t start,
+    Py_ssize_t end);
+#endif
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+/* Copy the string into a UCS4 buffer including the null character if copy_null
+   is set. Return NULL and raise an exception on error. Raise a SystemError if
+   the buffer is smaller than the string. Return buffer on success.
+
+   buflen is the length of the buffer in (Py_UCS4) characters. */
+PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4(
+    PyObject *unicode,
+    Py_UCS4* buffer,
+    Py_ssize_t buflen,
+    int copy_null);
+
+/* Copy the string into a UCS4 buffer. A new buffer is allocated using
+ * PyMem_Malloc; if this fails, NULL is returned with a memory error
+   exception set. */
+PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4Copy(PyObject *unicode);
+#endif
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+/* Get the length of the Unicode object. */
+
+PyAPI_FUNC(Py_ssize_t) PyUnicode_GetLength(
+    PyObject *unicode
+);
+#endif
+
+/* Get the number of Py_UNICODE units in the
+   string representation. */
+
+Py_DEPRECATED(3.3) PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize(
+    PyObject *unicode           /* Unicode object */
+    );
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+/* Read a character from the string. */
+
+PyAPI_FUNC(Py_UCS4) PyUnicode_ReadChar(
+    PyObject *unicode,
+    Py_ssize_t index
+    );
+
+/* Write a character to the string. The string must have been created through
+   PyUnicode_New, must not be shared, and must not have been hashed yet.
+
+   Return 0 on success, -1 on error. */
+
+PyAPI_FUNC(int) PyUnicode_WriteChar(
+    PyObject *unicode,
+    Py_ssize_t index,
+    Py_UCS4 character
+    );
+#endif
+
+/* Resize a Unicode object. The length is the number of characters, except
+   if the kind of the string is PyUnicode_WCHAR_KIND: in this case, the length
+   is the number of Py_UNICODE characters.
+
+   *unicode is modified to point to the new (resized) object and 0
+   returned on success.
+
+   Try to resize the string in place (which is usually faster than allocating
+   a new string and copy characters), or create a new string.
+
+   Error handling is implemented as follows: an exception is set, -1
+   is returned and *unicode left untouched.
+
+   WARNING: The function doesn't check string content, the result may not be a
+            string in canonical representation. */
+
+PyAPI_FUNC(int) PyUnicode_Resize(
+    PyObject **unicode,         /* Pointer to the Unicode object */
+    Py_ssize_t length           /* New length */
+    );
+
+/* Decode obj to a Unicode object.
+
+   bytes, bytearray and other bytes-like objects are decoded according to the
+   given encoding and error handler. The encoding and error handler can be
+   NULL to have the interface use UTF-8 and "strict".
+
+   All other objects (including Unicode objects) raise an exception.
+
+   The API returns NULL in case of an error. The caller is responsible
+   for decref'ing the returned objects.
+
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject(
+    PyObject *obj,              /* Object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
+    );
+
+/* Copy an instance of a Unicode subtype to a new true Unicode object if
+   necessary. If obj is already a true Unicode object (not a subtype), return
+   the reference with *incremented* refcount.
+
+   The API returns NULL in case of an error. The caller is responsible
+   for decref'ing the returned objects.
+
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_FromObject(
+    PyObject *obj      /* Object */
+    );
+
+PyAPI_FUNC(PyObject *) PyUnicode_FromFormatV(
+    const char *format,   /* ASCII-encoded string  */
+    va_list vargs
+    );
+PyAPI_FUNC(PyObject *) PyUnicode_FromFormat(
+    const char *format,   /* ASCII-encoded string  */
+    ...
+    );
+
+PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **);
+PyAPI_FUNC(void) PyUnicode_InternImmortal(PyObject **);
+PyAPI_FUNC(PyObject *) PyUnicode_InternFromString(
+    const char *u              /* UTF-8 encoded string */
+    );
+
+/* Use only if you know it's a string */
+#define PyUnicode_CHECK_INTERNED(op) \
+    (((PyASCIIObject *)(op))->state.interned)
+
+/* --- wchar_t support for platforms which support it --------------------- */
+
+#ifdef HAVE_WCHAR_H
+
+/* Create a Unicode Object from the wchar_t buffer w of the given
+   size.
+
+   The buffer is copied into the new object. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar(
+    const wchar_t *w,           /* wchar_t buffer */
+    Py_ssize_t size             /* size of buffer */
+    );
+
+/* Copies the Unicode Object contents into the wchar_t buffer w.  At
+   most size wchar_t characters are copied.
+
+   Note that the resulting wchar_t string may or may not be
+   0-terminated.  It is the responsibility of the caller to make sure
+   that the wchar_t string is 0-terminated in case this is required by
+   the application.
+
+   Returns the number of wchar_t characters copied (excluding a
+   possibly trailing 0-termination character) or -1 in case of an
+   error. */
+
+PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar(
+    PyObject *unicode,          /* Unicode object */
+    wchar_t *w,                 /* wchar_t buffer */
+    Py_ssize_t size             /* size of buffer */
+    );
+
+/* Convert the Unicode object to a wide character string. The output string
+   always ends with a nul character. If size is not NULL, write the number of
+   wide characters (excluding the null character) into *size.
+
+   Returns a buffer allocated by PyMem_Malloc() (use PyMem_Free() to free it)
+   on success. On error, returns NULL, *size is undefined and raises a
+   MemoryError. */
+
+PyAPI_FUNC(wchar_t*) PyUnicode_AsWideCharString(
+    PyObject *unicode,          /* Unicode object */
+    Py_ssize_t *size            /* number of characters of the result */
+    );
+
+#endif
+
+/* --- Unicode ordinals --------------------------------------------------- */
+
+/* Create a Unicode Object from the given Unicode code point ordinal.
+
+   The ordinal must be in range(0x110000). A ValueError is
+   raised in case it is not.
+
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_FromOrdinal(int ordinal);
+
+/* === Builtin Codecs =====================================================
+
+   Many of these APIs take two arguments encoding and errors. These
+   parameters encoding and errors have the same semantics as the ones
+   of the builtin str() API.
+
+   Setting encoding to NULL causes the default encoding (UTF-8) to be used.
+
+   Error handling is set by errors which may also be set to NULL
+   meaning to use the default handling defined for the codec. Default
+   error handling for all builtin codecs is "strict" (ValueErrors are
+   raised).
+
+   The codecs all use a similar interface. Only deviation from the
+   generic ones are documented.
+
+*/
+
+/* --- Manage the default encoding ---------------------------------------- */
+
+/* Returns "utf-8".  */
+PyAPI_FUNC(const char*) PyUnicode_GetDefaultEncoding(void);
+
+/* --- Generic Codecs ----------------------------------------------------- */
+
+/* Create a Unicode object by decoding the encoded string s of the
+   given size. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_Decode(
+    const char *s,              /* encoded string */
+    Py_ssize_t size,            /* size of buffer */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
+    );
+
+/* Decode a Unicode object unicode and return the result as Python
+   object.
+
+   This API is DEPRECATED. The only supported standard encoding is rot13.
+   Use PyCodec_Decode() to decode with rot13 and non-standard codecs
+   that decode from str. */
+
+Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedObject(
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
+    );
+
+/* Decode a Unicode object unicode and return the result as Unicode
+   object.
+
+   This API is DEPRECATED. The only supported standard encoding is rot13.
+   Use PyCodec_Decode() to decode with rot13 and non-standard codecs
+   that decode from str to str. */
+
+Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedUnicode(
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
+    );
+
+/* Encodes a Unicode object and returns the result as Python
+   object.
+
+   This API is DEPRECATED.  It is superseded by PyUnicode_AsEncodedString()
+   since all standard encodings (except rot13) encode str to bytes.
+   Use PyCodec_Encode() for encoding with rot13 and non-standard codecs
+   that encode form str to non-bytes. */
+
+Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject(
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
+    );
+
+/* Encodes a Unicode object and returns the result as Python string
+   object. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString(
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
+    );
+
+/* Encodes a Unicode object and returns the result as Unicode
+   object.
+
+   This API is DEPRECATED.  The only supported standard encodings is rot13.
+   Use PyCodec_Encode() to encode with rot13 and non-standard codecs
+   that encode from str to str. */
+
+Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedUnicode(
+    PyObject *unicode,          /* Unicode object */
+    const char *encoding,       /* encoding */
+    const char *errors          /* error handling */
+    );
+
+/* Build an encoding map. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_BuildEncodingMap(
+    PyObject* string            /* 256 character map */
+   );
+
+/* --- UTF-7 Codecs ------------------------------------------------------- */
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7(
+    const char *string,         /* UTF-7 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7Stateful(
+    const char *string,         /* UTF-7 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    Py_ssize_t *consumed        /* bytes consumed */
+    );
+
+/* --- UTF-8 Codecs ------------------------------------------------------- */
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8(
+    const char *string,         /* UTF-8 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8Stateful(
+    const char *string,         /* UTF-8 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    Py_ssize_t *consumed        /* bytes consumed */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* --- UTF-32 Codecs ------------------------------------------------------ */
+
+/* Decodes length bytes from a UTF-32 encoded buffer string and returns
+   the corresponding Unicode object.
+
+   errors (if non-NULL) defines the error handling. It defaults
+   to "strict".
+
+   If byteorder is non-NULL, the decoder starts decoding using the
+   given byte order:
+
+    *byteorder == -1: little endian
+    *byteorder == 0:  native order
+    *byteorder == 1:  big endian
+
+   In native mode, the first four bytes of the stream are checked for a
+   BOM mark. If found, the BOM mark is analysed, the byte order
+   adjusted and the BOM skipped.  In the other modes, no BOM mark
+   interpretation is done. After completion, *byteorder is set to the
+   current byte order at the end of input data.
+
+   If byteorder is NULL, the codec starts in native order mode.
+
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32(
+    const char *string,         /* UTF-32 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder              /* pointer to byteorder to use
+                                   0=native;-1=LE,1=BE; updated on
+                                   exit */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32Stateful(
+    const char *string,         /* UTF-32 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder,             /* pointer to byteorder to use
+                                   0=native;-1=LE,1=BE; updated on
+                                   exit */
+    Py_ssize_t *consumed        /* bytes consumed */
+    );
+
+/* Returns a Python string using the UTF-32 encoding in native byte
+   order. The string always starts with a BOM mark.  */
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsUTF32String(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* Returns a Python string object holding the UTF-32 encoded value of
+   the Unicode data.
+
+   If byteorder is not 0, output is written according to the following
+   byte order:
+
+   byteorder == -1: little endian
+   byteorder == 0:  native byte order (writes a BOM mark)
+   byteorder == 1:  big endian
+
+   If byteorder is 0, the output string will always start with the
+   Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
+   prepended.
+
+*/
+
+/* --- UTF-16 Codecs ------------------------------------------------------ */
+
+/* Decodes length bytes from a UTF-16 encoded buffer string and returns
+   the corresponding Unicode object.
+
+   errors (if non-NULL) defines the error handling. It defaults
+   to "strict".
+
+   If byteorder is non-NULL, the decoder starts decoding using the
+   given byte order:
+
+    *byteorder == -1: little endian
+    *byteorder == 0:  native order
+    *byteorder == 1:  big endian
+
+   In native mode, the first two bytes of the stream are checked for a
+   BOM mark. If found, the BOM mark is analysed, the byte order
+   adjusted and the BOM skipped.  In the other modes, no BOM mark
+   interpretation is done. After completion, *byteorder is set to the
+   current byte order at the end of input data.
+
+   If byteorder is NULL, the codec starts in native order mode.
+
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16(
+    const char *string,         /* UTF-16 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder              /* pointer to byteorder to use
+                                   0=native;-1=LE,1=BE; updated on
+                                   exit */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16Stateful(
+    const char *string,         /* UTF-16 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    int *byteorder,             /* pointer to byteorder to use
+                                   0=native;-1=LE,1=BE; updated on
+                                   exit */
+    Py_ssize_t *consumed        /* bytes consumed */
+    );
+
+/* Returns a Python string using the UTF-16 encoding in native byte
+   order. The string always starts with a BOM mark.  */
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* --- Unicode-Escape Codecs ---------------------------------------------- */
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape(
+    const char *string,         /* Unicode-Escape encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape(
+    const char *string,         /* Raw-Unicode-Escape encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* --- Latin-1 Codecs -----------------------------------------------------
+
+   Note: Latin-1 corresponds to the first 256 Unicode ordinals. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1(
+    const char *string,         /* Latin-1 encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* --- ASCII Codecs -------------------------------------------------------
+
+   Only 7-bit ASCII data is excepted. All other codes generate errors.
+
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeASCII(
+    const char *string,         /* ASCII encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString(
+    PyObject *unicode           /* Unicode object */
+    );
+
+/* --- Character Map Codecs -----------------------------------------------
+
+   This codec uses mappings to encode and decode characters.
+
+   Decoding mappings must map byte ordinals (integers in the range from 0 to
+   255) to Unicode strings, integers (which are then interpreted as Unicode
+   ordinals) or None.  Unmapped data bytes (ones which cause a LookupError)
+   as well as mapped to None, 0xFFFE or '\ufffe' are treated as "undefined
+   mapping" and cause an error.
+
+   Encoding mappings must map Unicode ordinal integers to bytes objects,
+   integers in the range from 0 to 255 or None.  Unmapped character
+   ordinals (ones which cause a LookupError) as well as mapped to
+   None are treated as "undefined mapping" and cause an error.
+
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeCharmap(
+    const char *string,         /* Encoded string */
+    Py_ssize_t length,          /* size of string */
+    PyObject *mapping,          /* decoding mapping */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString(
+    PyObject *unicode,          /* Unicode object */
+    PyObject *mapping           /* encoding mapping */
+    );
+
+/* --- MBCS codecs for Windows -------------------------------------------- */
+
+#ifdef MS_WINDOWS
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCS(
+    const char *string,         /* MBCS encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors          /* error handling */
+    );
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCSStateful(
+    const char *string,         /* MBCS encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    Py_ssize_t *consumed        /* bytes consumed */
+    );
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeCodePageStateful(
+    int code_page,              /* code page number */
+    const char *string,         /* encoded string */
+    Py_ssize_t length,          /* size of string */
+    const char *errors,         /* error handling */
+    Py_ssize_t *consumed        /* bytes consumed */
+    );
+#endif
+
+PyAPI_FUNC(PyObject*) PyUnicode_AsMBCSString(
+    PyObject *unicode           /* Unicode object */
+    );
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeCodePage(
+    int code_page,              /* code page number */
+    PyObject *unicode,          /* Unicode object */
+    const char *errors          /* error handling */
+    );
+#endif
+
+#endif /* MS_WINDOWS */
+
+/* --- Locale encoding --------------------------------------------------- */
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+/* Decode a string from the current locale encoding. The decoder is strict if
+   *surrogateescape* is equal to zero, otherwise it uses the 'surrogateescape'
+   error handler (PEP 383) to escape undecodable bytes. If a byte sequence can
+   be decoded as a surrogate character and *surrogateescape* is not equal to
+   zero, the byte sequence is escaped using the 'surrogateescape' error handler
+   instead of being decoded. *str* must end with a null character but cannot
+   contain embedded null characters. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeLocaleAndSize(
+    const char *str,
+    Py_ssize_t len,
+    const char *errors);
+
+/* Similar to PyUnicode_DecodeLocaleAndSize(), but compute the string
+   length using strlen(). */
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeLocale(
+    const char *str,
+    const char *errors);
+
+/* Encode a Unicode object to the current locale encoding. The encoder is
+   strict is *surrogateescape* is equal to zero, otherwise the
+   "surrogateescape" error handler is used. Return a bytes object. The string
+   cannot contain embedded null characters. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeLocale(
+    PyObject *unicode,
+    const char *errors
+    );
+#endif
+
+/* --- File system encoding ---------------------------------------------- */
+
+/* ParseTuple converter: encode str objects to bytes using
+   PyUnicode_EncodeFSDefault(); bytes objects are output as-is. */
+
+PyAPI_FUNC(int) PyUnicode_FSConverter(PyObject*, void*);
+
+/* ParseTuple converter: decode bytes objects to unicode using
+   PyUnicode_DecodeFSDefaultAndSize(); str objects are output as-is. */
+
+PyAPI_FUNC(int) PyUnicode_FSDecoder(PyObject*, void*);
+
+/* Decode a null-terminated string using Py_FileSystemDefaultEncoding
+   and the "surrogateescape" error handler.
+
+   If Py_FileSystemDefaultEncoding is not set, fall back to the locale
+   encoding.
+
+   Use PyUnicode_DecodeFSDefaultAndSize() if the string length is known.
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeFSDefault(
+    const char *s               /* encoded string */
+    );
+
+/* Decode a string using Py_FileSystemDefaultEncoding
+   and the "surrogateescape" error handler.
+
+   If Py_FileSystemDefaultEncoding is not set, fall back to the locale
+   encoding.
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeFSDefaultAndSize(
+    const char *s,               /* encoded string */
+    Py_ssize_t size              /* size */
+    );
+
+/* Encode a Unicode object to Py_FileSystemDefaultEncoding with the
+   "surrogateescape" error handler, and return bytes.
+
+   If Py_FileSystemDefaultEncoding is not set, fall back to the locale
+   encoding.
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeFSDefault(
+    PyObject *unicode
+    );
+
+/* --- Methods & Slots ----------------------------------------------------
+
+   These are capable of handling Unicode objects and strings on input
+   (we refer to them as strings in the descriptions) and return
+   Unicode objects or integers as appropriate. */
+
+/* Concat two strings giving a new Unicode string. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_Concat(
+    PyObject *left,             /* Left string */
+    PyObject *right             /* Right string */
+    );
+
+/* Concat two strings and put the result in *pleft
+   (sets *pleft to NULL on error) */
+
+PyAPI_FUNC(void) PyUnicode_Append(
+    PyObject **pleft,           /* Pointer to left string */
+    PyObject *right             /* Right string */
+    );
+
+/* Concat two strings, put the result in *pleft and drop the right object
+   (sets *pleft to NULL on error) */
+
+PyAPI_FUNC(void) PyUnicode_AppendAndDel(
+    PyObject **pleft,           /* Pointer to left string */
+    PyObject *right             /* Right string */
+    );
+
+/* Split a string giving a list of Unicode strings.
+
+   If sep is NULL, splitting will be done at all whitespace
+   substrings. Otherwise, splits occur at the given separator.
+
+   At most maxsplit splits will be done. If negative, no limit is set.
+
+   Separators are not included in the resulting list.
+
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_Split(
+    PyObject *s,                /* String to split */
+    PyObject *sep,              /* String separator */
+    Py_ssize_t maxsplit         /* Maxsplit count */
+    );
+
+/* Dito, but split at line breaks.
+
+   CRLF is considered to be one line break. Line breaks are not
+   included in the resulting list. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_Splitlines(
+    PyObject *s,                /* String to split */
+    int keepends                /* If true, line end markers are included */
+    );
+
+/* Partition a string using a given separator. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_Partition(
+    PyObject *s,                /* String to partition */
+    PyObject *sep               /* String separator */
+    );
+
+/* Partition a string using a given separator, searching from the end of the
+   string. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_RPartition(
+    PyObject *s,                /* String to partition */
+    PyObject *sep               /* String separator */
+    );
+
+/* Split a string giving a list of Unicode strings.
+
+   If sep is NULL, splitting will be done at all whitespace
+   substrings. Otherwise, splits occur at the given separator.
+
+   At most maxsplit splits will be done. But unlike PyUnicode_Split
+   PyUnicode_RSplit splits from the end of the string. If negative,
+   no limit is set.
+
+   Separators are not included in the resulting list.
+
+*/
+
+PyAPI_FUNC(PyObject*) PyUnicode_RSplit(
+    PyObject *s,                /* String to split */
+    PyObject *sep,              /* String separator */
+    Py_ssize_t maxsplit         /* Maxsplit count */
+    );
+
+/* Translate a string by applying a character mapping table to it and
+   return the resulting Unicode object.
+
+   The mapping table must map Unicode ordinal integers to Unicode strings,
+   Unicode ordinal integers or None (causing deletion of the character).
+
+   Mapping tables may be dictionaries or sequences. Unmapped character
+   ordinals (ones which cause a LookupError) are left untouched and
+   are copied as-is.
+
+*/
+
+PyAPI_FUNC(PyObject *) PyUnicode_Translate(
+    PyObject *str,              /* String */
+    PyObject *table,            /* Translate table */
+    const char *errors          /* error handling */
+    );
+
+/* Join a sequence of strings using the given separator and return
+   the resulting Unicode string. */
+
+PyAPI_FUNC(PyObject*) PyUnicode_Join(
+    PyObject *separator,        /* Separator string */
+    PyObject *seq               /* Sequence object */
+    );
+
+/* Return 1 if substr matches str[start:end] at the given tail end, 0
+   otherwise. */
+
+PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch(
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Prefix or Suffix string */
+    Py_ssize_t start,           /* Start index */
+    Py_ssize_t end,             /* Stop index */
+    int direction               /* Tail end: -1 prefix, +1 suffix */
+    );
+
+/* Return the first position of substr in str[start:end] using the
+   given search direction or -1 if not found. -2 is returned in case
+   an error occurred and an exception is set. */
+
+PyAPI_FUNC(Py_ssize_t) PyUnicode_Find(
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Substring to find */
+    Py_ssize_t start,           /* Start index */
+    Py_ssize_t end,             /* Stop index */
+    int direction               /* Find direction: +1 forward, -1 backward */
+    );
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
+/* Like PyUnicode_Find, but search for single character only. */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_FindChar(
+    PyObject *str,
+    Py_UCS4 ch,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    int direction
+    );
+#endif
+
+/* Count the number of occurrences of substr in str[start:end]. */
+
+PyAPI_FUNC(Py_ssize_t) PyUnicode_Count(
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Substring to count */
+    Py_ssize_t start,           /* Start index */
+    Py_ssize_t end              /* Stop index */
+    );
+
+/* Replace at most maxcount occurrences of substr in str with replstr
+   and return the resulting Unicode object. */
+
+PyAPI_FUNC(PyObject *) PyUnicode_Replace(
+    PyObject *str,              /* String */
+    PyObject *substr,           /* Substring to find */
+    PyObject *replstr,          /* Substring to replace */
+    Py_ssize_t maxcount         /* Max. number of replacements to apply;
+                                   -1 = all */
+    );
+
+/* Compare two strings and return -1, 0, 1 for less than, equal,
+   greater than resp.
+   Raise an exception and return -1 on error. */
+
+PyAPI_FUNC(int) PyUnicode_Compare(
+    PyObject *left,             /* Left string */
+    PyObject *right             /* Right string */
+    );
+
+/* Compare a Unicode object with C string and return -1, 0, 1 for less than,
+   equal, and greater than, respectively.  It is best to pass only
+   ASCII-encoded strings, but the function interprets the input string as
+   ISO-8859-1 if it contains non-ASCII characters.
+   This function does not raise exceptions. */
+
+PyAPI_FUNC(int) PyUnicode_CompareWithASCIIString(
+    PyObject *left,
+    const char *right           /* ASCII-encoded string */
+    );
+
+/* Rich compare two strings and return one of the following:
+
+   - NULL in case an exception was raised
+   - Py_True or Py_False for successful comparisons
+   - Py_NotImplemented in case the type combination is unknown
+
+   Possible values for op:
+
+     Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE
+
+*/
+
+PyAPI_FUNC(PyObject *) PyUnicode_RichCompare(
+    PyObject *left,             /* Left string */
+    PyObject *right,            /* Right string */
+    int op                      /* Operation: Py_EQ, Py_NE, Py_GT, etc. */
+    );
+
+/* Apply an argument tuple or dictionary to a format string and return
+   the resulting Unicode string. */
+
+PyAPI_FUNC(PyObject *) PyUnicode_Format(
+    PyObject *format,           /* Format string */
+    PyObject *args              /* Argument tuple or dictionary */
+    );
+
+/* Checks whether element is contained in container and return 1/0
+   accordingly.
+
+   element has to coerce to a one element Unicode string. -1 is
+   returned in case of an error. */
+
+PyAPI_FUNC(int) PyUnicode_Contains(
+    PyObject *container,        /* Container string */
+    PyObject *element           /* Element string */
+    );
+
+/* Checks whether argument is a valid identifier. */
+
+PyAPI_FUNC(int) PyUnicode_IsIdentifier(PyObject *s);
+
+/* === Characters Type APIs =============================================== */
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_UNICODEOBJECT_H
+#  include  "cpython/unicodeobject.h"
+#  undef Py_CPYTHON_UNICODEOBJECT_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_UNICODEOBJECT_H */
diff --git a/marketing/include/warnings.h b/marketing/include/warnings.h
new file mode 100644
index 0000000000000000000000000000000000000000..a675bb5dfcb9f5009c70b9e7fe3ecf6e20e76866
--- /dev/null
+++ b/marketing/include/warnings.h
@@ -0,0 +1,67 @@
+#ifndef Py_WARNINGS_H
+#define Py_WARNINGS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(PyObject*) _PyWarnings_Init(void);
+#endif
+
+PyAPI_FUNC(int) PyErr_WarnEx(
+    PyObject *category,
+    const char *message,        /* UTF-8 encoded string */
+    Py_ssize_t stack_level);
+PyAPI_FUNC(int) PyErr_WarnFormat(
+    PyObject *category,
+    Py_ssize_t stack_level,
+    const char *format,         /* ASCII-encoded string  */
+    ...);
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+/* Emit a ResourceWarning warning */
+PyAPI_FUNC(int) PyErr_ResourceWarning(
+    PyObject *source,
+    Py_ssize_t stack_level,
+    const char *format,         /* ASCII-encoded string  */
+    ...);
+#endif
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(int) PyErr_WarnExplicitObject(
+    PyObject *category,
+    PyObject *message,
+    PyObject *filename,
+    int lineno,
+    PyObject *module,
+    PyObject *registry);
+#endif
+PyAPI_FUNC(int) PyErr_WarnExplicit(
+    PyObject *category,
+    const char *message,        /* UTF-8 encoded string */
+    const char *filename,       /* decoded from the filesystem encoding */
+    int lineno,
+    const char *module,         /* UTF-8 encoded string */
+    PyObject *registry);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(int)
+PyErr_WarnExplicitFormat(PyObject *category,
+                         const char *filename, int lineno,
+                         const char *module, PyObject *registry,
+                         const char *format, ...);
+#endif
+
+/* DEPRECATED: Use PyErr_WarnEx() instead. */
+#ifndef Py_LIMITED_API
+#define PyErr_Warn(category, msg) PyErr_WarnEx(category, msg, 1)
+#endif
+
+#ifndef Py_LIMITED_API
+void _PyErr_WarnUnawaitedCoroutine(PyObject *coro);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_WARNINGS_H */
+
diff --git a/marketing/include/weakrefobject.h b/marketing/include/weakrefobject.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac4b4821c8a1470fd8e0b5f078b62da1521ebf2e
--- /dev/null
+++ b/marketing/include/weakrefobject.h
@@ -0,0 +1,86 @@
+/* Weak references objects for Python. */
+
+#ifndef Py_WEAKREFOBJECT_H
+#define Py_WEAKREFOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct _PyWeakReference PyWeakReference;
+
+/* PyWeakReference is the base struct for the Python ReferenceType, ProxyType,
+ * and CallableProxyType.
+ */
+#ifndef Py_LIMITED_API
+struct _PyWeakReference {
+    PyObject_HEAD
+
+    /* The object to which this is a weak reference, or Py_None if none.
+     * Note that this is a stealth reference:  wr_object's refcount is
+     * not incremented to reflect this pointer.
+     */
+    PyObject *wr_object;
+
+    /* A callable to invoke when wr_object dies, or NULL if none. */
+    PyObject *wr_callback;
+
+    /* A cache for wr_object's hash code.  As usual for hashes, this is -1
+     * if the hash code isn't known yet.
+     */
+    Py_hash_t hash;
+
+    /* If wr_object is weakly referenced, wr_object has a doubly-linked NULL-
+     * terminated list of weak references to it.  These are the list pointers.
+     * If wr_object goes away, wr_object is set to Py_None, and these pointers
+     * have no meaning then.
+     */
+    PyWeakReference *wr_prev;
+    PyWeakReference *wr_next;
+};
+#endif
+
+PyAPI_DATA(PyTypeObject) _PyWeakref_RefType;
+PyAPI_DATA(PyTypeObject) _PyWeakref_ProxyType;
+PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType;
+
+#define PyWeakref_CheckRef(op) PyObject_TypeCheck(op, &_PyWeakref_RefType)
+#define PyWeakref_CheckRefExact(op) \
+        Py_IS_TYPE(op, &_PyWeakref_RefType)
+#define PyWeakref_CheckProxy(op) \
+        (Py_IS_TYPE(op, &_PyWeakref_ProxyType) || \
+         Py_IS_TYPE(op, &_PyWeakref_CallableProxyType))
+
+#define PyWeakref_Check(op) \
+        (PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op))
+
+
+PyAPI_FUNC(PyObject *) PyWeakref_NewRef(PyObject *ob,
+                                              PyObject *callback);
+PyAPI_FUNC(PyObject *) PyWeakref_NewProxy(PyObject *ob,
+                                                PyObject *callback);
+PyAPI_FUNC(PyObject *) PyWeakref_GetObject(PyObject *ref);
+
+#ifndef Py_LIMITED_API
+PyAPI_FUNC(Py_ssize_t) _PyWeakref_GetWeakrefCount(PyWeakReference *head);
+
+PyAPI_FUNC(void) _PyWeakref_ClearRef(PyWeakReference *self);
+#endif
+
+/* Explanation for the Py_REFCNT() check: when a weakref's target is part
+   of a long chain of deallocations which triggers the trashcan mechanism,
+   clearing the weakrefs can be delayed long after the target's refcount
+   has dropped to zero.  In the meantime, code accessing the weakref will
+   be able to "see" the target object even though it is supposed to be
+   unreachable.  See issue #16602. */
+
+#define PyWeakref_GET_OBJECT(ref)                           \
+    (Py_REFCNT(((PyWeakReference *)(ref))->wr_object) > 0   \
+     ? ((PyWeakReference *)(ref))->wr_object                \
+     : Py_None)
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_WEAKREFOBJECT_H */
diff --git a/marketing/msvcp140_1.dll b/marketing/msvcp140_1.dll
new file mode 100644
index 0000000000000000000000000000000000000000..9dc8aa784907197cace29dbfc882101a463ee07b
Binary files /dev/null and b/marketing/msvcp140_1.dll differ
diff --git a/marketing/msvcp140_atomic_wait.dll b/marketing/msvcp140_atomic_wait.dll
new file mode 100644
index 0000000000000000000000000000000000000000..469f90015a8b5cef85c0f3de2d407cc2f7c9d516
Binary files /dev/null and b/marketing/msvcp140_atomic_wait.dll differ
diff --git a/marketing/msvcp140_codecvt_ids.dll b/marketing/msvcp140_codecvt_ids.dll
new file mode 100644
index 0000000000000000000000000000000000000000..df9573151ad4c9f2ea320a39a76f9f9055e612d0
Binary files /dev/null and b/marketing/msvcp140_codecvt_ids.dll differ
diff --git a/marketing/python3.dll b/marketing/python3.dll
new file mode 100644
index 0000000000000000000000000000000000000000..71fb3b939b189cad76d7ae9c4c2b27632992fbf3
Binary files /dev/null and b/marketing/python3.dll differ
diff --git a/marketing/share/zoneinfo/Africa/Abidjan b/marketing/share/zoneinfo/Africa/Abidjan
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Abidjan differ
diff --git a/marketing/share/zoneinfo/Africa/Accra b/marketing/share/zoneinfo/Africa/Accra
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Accra differ
diff --git a/marketing/share/zoneinfo/Africa/Addis_Ababa b/marketing/share/zoneinfo/Africa/Addis_Ababa
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Addis_Ababa differ
diff --git a/marketing/share/zoneinfo/Africa/Algiers b/marketing/share/zoneinfo/Africa/Algiers
new file mode 100644
index 0000000000000000000000000000000000000000..56a4dd2a19fac5cc1bb1951dedf3ae93e0b9e321
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Algiers differ
diff --git a/marketing/share/zoneinfo/Africa/Asmara b/marketing/share/zoneinfo/Africa/Asmara
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Asmara differ
diff --git a/marketing/share/zoneinfo/Africa/Asmera b/marketing/share/zoneinfo/Africa/Asmera
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Asmera differ
diff --git a/marketing/share/zoneinfo/Africa/Bamako b/marketing/share/zoneinfo/Africa/Bamako
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Bamako differ
diff --git a/marketing/share/zoneinfo/Africa/Bangui b/marketing/share/zoneinfo/Africa/Bangui
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Bangui differ
diff --git a/marketing/share/zoneinfo/Africa/Banjul b/marketing/share/zoneinfo/Africa/Banjul
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Banjul differ
diff --git a/marketing/share/zoneinfo/Africa/Bissau b/marketing/share/zoneinfo/Africa/Bissau
new file mode 100644
index 0000000000000000000000000000000000000000..0da1d1e211bc6b9b081959c1d510583cb9eb7102
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Bissau differ
diff --git a/marketing/share/zoneinfo/Africa/Blantyre b/marketing/share/zoneinfo/Africa/Blantyre
new file mode 100644
index 0000000000000000000000000000000000000000..581bb0e08b616a433d422ccb8f958cbebdae1770
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Blantyre differ
diff --git a/marketing/share/zoneinfo/Africa/Brazzaville b/marketing/share/zoneinfo/Africa/Brazzaville
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Brazzaville differ
diff --git a/marketing/share/zoneinfo/Africa/Bujumbura b/marketing/share/zoneinfo/Africa/Bujumbura
new file mode 100644
index 0000000000000000000000000000000000000000..581bb0e08b616a433d422ccb8f958cbebdae1770
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Bujumbura differ
diff --git a/marketing/share/zoneinfo/Africa/Cairo b/marketing/share/zoneinfo/Africa/Cairo
new file mode 100644
index 0000000000000000000000000000000000000000..1e6d48d1ca4e5416913c41e8814dc045c57d5b58
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Cairo differ
diff --git a/marketing/share/zoneinfo/Africa/Casablanca b/marketing/share/zoneinfo/Africa/Casablanca
new file mode 100644
index 0000000000000000000000000000000000000000..240ebb2bfb22642570a6053445a6e71864e7f48a
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Casablanca differ
diff --git a/marketing/share/zoneinfo/Africa/Ceuta b/marketing/share/zoneinfo/Africa/Ceuta
new file mode 100644
index 0000000000000000000000000000000000000000..a461dceaa2adccd6cb3196b6eccf5395130881ff
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Ceuta differ
diff --git a/marketing/share/zoneinfo/Africa/Conakry b/marketing/share/zoneinfo/Africa/Conakry
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Conakry differ
diff --git a/marketing/share/zoneinfo/Africa/Dakar b/marketing/share/zoneinfo/Africa/Dakar
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Dakar differ
diff --git a/marketing/share/zoneinfo/Africa/Dar_es_Salaam b/marketing/share/zoneinfo/Africa/Dar_es_Salaam
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Dar_es_Salaam differ
diff --git a/marketing/share/zoneinfo/Africa/Djibouti b/marketing/share/zoneinfo/Africa/Djibouti
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Djibouti differ
diff --git a/marketing/share/zoneinfo/Africa/Douala b/marketing/share/zoneinfo/Africa/Douala
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Douala differ
diff --git a/marketing/share/zoneinfo/Africa/El_Aaiun b/marketing/share/zoneinfo/Africa/El_Aaiun
new file mode 100644
index 0000000000000000000000000000000000000000..909c5f9682927c14e3e64e21da75559ad2e598f9
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/El_Aaiun differ
diff --git a/marketing/share/zoneinfo/Africa/Freetown b/marketing/share/zoneinfo/Africa/Freetown
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Freetown differ
diff --git a/marketing/share/zoneinfo/Africa/Gaborone b/marketing/share/zoneinfo/Africa/Gaborone
new file mode 100644
index 0000000000000000000000000000000000000000..581bb0e08b616a433d422ccb8f958cbebdae1770
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Gaborone differ
diff --git a/marketing/share/zoneinfo/Africa/Harare b/marketing/share/zoneinfo/Africa/Harare
new file mode 100644
index 0000000000000000000000000000000000000000..581bb0e08b616a433d422ccb8f958cbebdae1770
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Harare differ
diff --git a/marketing/share/zoneinfo/Africa/Johannesburg b/marketing/share/zoneinfo/Africa/Johannesburg
new file mode 100644
index 0000000000000000000000000000000000000000..bada0638f8a2224a603f13afff16c0d8e986a591
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Johannesburg differ
diff --git a/marketing/share/zoneinfo/Africa/Juba b/marketing/share/zoneinfo/Africa/Juba
new file mode 100644
index 0000000000000000000000000000000000000000..0aba9ffd89dcbb47f1bf003dad75227f08d99679
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Juba differ
diff --git a/marketing/share/zoneinfo/Africa/Kampala b/marketing/share/zoneinfo/Africa/Kampala
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Kampala differ
diff --git a/marketing/share/zoneinfo/Africa/Khartoum b/marketing/share/zoneinfo/Africa/Khartoum
new file mode 100644
index 0000000000000000000000000000000000000000..3f8e44b8a6e171a0fde96736ed9d4fcde1bcd4a8
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Khartoum differ
diff --git a/marketing/share/zoneinfo/Africa/Kigali b/marketing/share/zoneinfo/Africa/Kigali
new file mode 100644
index 0000000000000000000000000000000000000000..581bb0e08b616a433d422ccb8f958cbebdae1770
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Kigali differ
diff --git a/marketing/share/zoneinfo/Africa/Kinshasa b/marketing/share/zoneinfo/Africa/Kinshasa
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Kinshasa differ
diff --git a/marketing/share/zoneinfo/Africa/Lagos b/marketing/share/zoneinfo/Africa/Lagos
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Lagos differ
diff --git a/marketing/share/zoneinfo/Africa/Libreville b/marketing/share/zoneinfo/Africa/Libreville
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Libreville differ
diff --git a/marketing/share/zoneinfo/Africa/Lome b/marketing/share/zoneinfo/Africa/Lome
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Lome differ
diff --git a/marketing/share/zoneinfo/Africa/Luanda b/marketing/share/zoneinfo/Africa/Luanda
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Luanda differ
diff --git a/marketing/share/zoneinfo/Africa/Lubumbashi b/marketing/share/zoneinfo/Africa/Lubumbashi
new file mode 100644
index 0000000000000000000000000000000000000000..581bb0e08b616a433d422ccb8f958cbebdae1770
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Lubumbashi differ
diff --git a/marketing/share/zoneinfo/Africa/Lusaka b/marketing/share/zoneinfo/Africa/Lusaka
new file mode 100644
index 0000000000000000000000000000000000000000..581bb0e08b616a433d422ccb8f958cbebdae1770
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Lusaka differ
diff --git a/marketing/share/zoneinfo/Africa/Malabo b/marketing/share/zoneinfo/Africa/Malabo
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Malabo differ
diff --git a/marketing/share/zoneinfo/Africa/Maputo b/marketing/share/zoneinfo/Africa/Maputo
new file mode 100644
index 0000000000000000000000000000000000000000..581bb0e08b616a433d422ccb8f958cbebdae1770
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Maputo differ
diff --git a/marketing/share/zoneinfo/Africa/Maseru b/marketing/share/zoneinfo/Africa/Maseru
new file mode 100644
index 0000000000000000000000000000000000000000..bada0638f8a2224a603f13afff16c0d8e986a591
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Maseru differ
diff --git a/marketing/share/zoneinfo/Africa/Mbabane b/marketing/share/zoneinfo/Africa/Mbabane
new file mode 100644
index 0000000000000000000000000000000000000000..bada0638f8a2224a603f13afff16c0d8e986a591
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Mbabane differ
diff --git a/marketing/share/zoneinfo/Africa/Mogadishu b/marketing/share/zoneinfo/Africa/Mogadishu
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Mogadishu differ
diff --git a/marketing/share/zoneinfo/Africa/Monrovia b/marketing/share/zoneinfo/Africa/Monrovia
new file mode 100644
index 0000000000000000000000000000000000000000..837780922f23fc58ff7f73930954840e9c63c908
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Monrovia differ
diff --git a/marketing/share/zoneinfo/Africa/Nairobi b/marketing/share/zoneinfo/Africa/Nairobi
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Nairobi differ
diff --git a/marketing/share/zoneinfo/Africa/Ndjamena b/marketing/share/zoneinfo/Africa/Ndjamena
new file mode 100644
index 0000000000000000000000000000000000000000..ecbc0966dc2dc01fd4f93139318eccc0dddce5a6
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Ndjamena differ
diff --git a/marketing/share/zoneinfo/Africa/Niamey b/marketing/share/zoneinfo/Africa/Niamey
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Niamey differ
diff --git a/marketing/share/zoneinfo/Africa/Nouakchott b/marketing/share/zoneinfo/Africa/Nouakchott
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Nouakchott differ
diff --git a/marketing/share/zoneinfo/Africa/Ouagadougou b/marketing/share/zoneinfo/Africa/Ouagadougou
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Ouagadougou differ
diff --git a/marketing/share/zoneinfo/Africa/Porto-Novo b/marketing/share/zoneinfo/Africa/Porto-Novo
new file mode 100644
index 0000000000000000000000000000000000000000..3d7a71ba0e96de946446fc96add2f38a806a44a5
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Porto-Novo differ
diff --git a/marketing/share/zoneinfo/Africa/Sao_Tome b/marketing/share/zoneinfo/Africa/Sao_Tome
new file mode 100644
index 0000000000000000000000000000000000000000..425ad3fda7c517742fe01db74e38c0130be4a7ab
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Sao_Tome differ
diff --git a/marketing/share/zoneinfo/Africa/Timbuktu b/marketing/share/zoneinfo/Africa/Timbuktu
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Timbuktu differ
diff --git a/marketing/share/zoneinfo/Africa/Tripoli b/marketing/share/zoneinfo/Africa/Tripoli
new file mode 100644
index 0000000000000000000000000000000000000000..e0c89971aabea2c87842a9276b043d0fd946e34e
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Tripoli differ
diff --git a/marketing/share/zoneinfo/Africa/Tunis b/marketing/share/zoneinfo/Africa/Tunis
new file mode 100644
index 0000000000000000000000000000000000000000..ca324cb4cd26cc29529faaee4c0465ae0cecc8f6
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Tunis differ
diff --git a/marketing/share/zoneinfo/Africa/Windhoek b/marketing/share/zoneinfo/Africa/Windhoek
new file mode 100644
index 0000000000000000000000000000000000000000..0edc52b9b783827a8ac1090fe350bfe13977f745
Binary files /dev/null and b/marketing/share/zoneinfo/Africa/Windhoek differ
diff --git a/marketing/share/zoneinfo/America/Adak b/marketing/share/zoneinfo/America/Adak
new file mode 100644
index 0000000000000000000000000000000000000000..b1497bda631efdcb6635ffb6b0ee6f7da9e2a280
Binary files /dev/null and b/marketing/share/zoneinfo/America/Adak differ
diff --git a/marketing/share/zoneinfo/America/Anchorage b/marketing/share/zoneinfo/America/Anchorage
new file mode 100644
index 0000000000000000000000000000000000000000..cdf0572be31d3052a98494e3d01802b83737f23c
Binary files /dev/null and b/marketing/share/zoneinfo/America/Anchorage differ
diff --git a/marketing/share/zoneinfo/America/Anguilla b/marketing/share/zoneinfo/America/Anguilla
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Anguilla differ
diff --git a/marketing/share/zoneinfo/America/Antigua b/marketing/share/zoneinfo/America/Antigua
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Antigua differ
diff --git a/marketing/share/zoneinfo/America/Araguaina b/marketing/share/zoneinfo/America/Araguaina
new file mode 100644
index 0000000000000000000000000000000000000000..f66c9f79d6cd4790c54d01286660f8ea0807f1c6
Binary files /dev/null and b/marketing/share/zoneinfo/America/Araguaina differ
diff --git a/marketing/share/zoneinfo/America/Argentina/Buenos_Aires b/marketing/share/zoneinfo/America/Argentina/Buenos_Aires
new file mode 100644
index 0000000000000000000000000000000000000000..d6f999b8605c9f73653a16e2ddbd5a49b96c0f56
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/Buenos_Aires differ
diff --git a/marketing/share/zoneinfo/America/Argentina/Catamarca b/marketing/share/zoneinfo/America/Argentina/Catamarca
new file mode 100644
index 0000000000000000000000000000000000000000..1dcc8d85434c9d016f170cb2f16811ebef327b77
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/Catamarca differ
diff --git a/marketing/share/zoneinfo/America/Argentina/ComodRivadavia b/marketing/share/zoneinfo/America/Argentina/ComodRivadavia
new file mode 100644
index 0000000000000000000000000000000000000000..1dcc8d85434c9d016f170cb2f16811ebef327b77
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/ComodRivadavia differ
diff --git a/marketing/share/zoneinfo/America/Argentina/Cordoba b/marketing/share/zoneinfo/America/Argentina/Cordoba
new file mode 100644
index 0000000000000000000000000000000000000000..35a52e53d123b5ef5d293b3af19046630f02bb66
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/Cordoba differ
diff --git a/marketing/share/zoneinfo/America/Argentina/Jujuy b/marketing/share/zoneinfo/America/Argentina/Jujuy
new file mode 100644
index 0000000000000000000000000000000000000000..b275f27c0287415674d2ccc850c3d612f4a45b0f
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/Jujuy differ
diff --git a/marketing/share/zoneinfo/America/Argentina/La_Rioja b/marketing/share/zoneinfo/America/Argentina/La_Rioja
new file mode 100644
index 0000000000000000000000000000000000000000..23fca12205222be27c167e597df5086520f699cf
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/La_Rioja differ
diff --git a/marketing/share/zoneinfo/America/Argentina/Mendoza b/marketing/share/zoneinfo/America/Argentina/Mendoza
new file mode 100644
index 0000000000000000000000000000000000000000..691c56978a033586e3302db2ef600e4b0ffd6366
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/Mendoza differ
diff --git a/marketing/share/zoneinfo/America/Argentina/Rio_Gallegos b/marketing/share/zoneinfo/America/Argentina/Rio_Gallegos
new file mode 100644
index 0000000000000000000000000000000000000000..991d1fae69ee1602fc6a07e6e85a3b62d66650c2
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/Rio_Gallegos differ
diff --git a/marketing/share/zoneinfo/America/Argentina/Salta b/marketing/share/zoneinfo/America/Argentina/Salta
new file mode 100644
index 0000000000000000000000000000000000000000..58863e0436d16ef8ff8ba3d96b452086e4ae8ff5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/Salta differ
diff --git a/marketing/share/zoneinfo/America/Argentina/San_Juan b/marketing/share/zoneinfo/America/Argentina/San_Juan
new file mode 100644
index 0000000000000000000000000000000000000000..7eba33c1c5b13cbd9b7566f450d524a45cf8b65e
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/San_Juan differ
diff --git a/marketing/share/zoneinfo/America/Argentina/San_Luis b/marketing/share/zoneinfo/America/Argentina/San_Luis
new file mode 100644
index 0000000000000000000000000000000000000000..0a81cbddfa2813041472b716baa91c35a8451379
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/San_Luis differ
diff --git a/marketing/share/zoneinfo/America/Argentina/Tucuman b/marketing/share/zoneinfo/America/Argentina/Tucuman
new file mode 100644
index 0000000000000000000000000000000000000000..10556d5d856a0f33afd8da2b07a2005e7be80fb0
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/Tucuman differ
diff --git a/marketing/share/zoneinfo/America/Argentina/Ushuaia b/marketing/share/zoneinfo/America/Argentina/Ushuaia
new file mode 100644
index 0000000000000000000000000000000000000000..e0317502769271ad0c038493df2ad2b90ec402d4
Binary files /dev/null and b/marketing/share/zoneinfo/America/Argentina/Ushuaia differ
diff --git a/marketing/share/zoneinfo/America/Aruba b/marketing/share/zoneinfo/America/Aruba
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Aruba differ
diff --git a/marketing/share/zoneinfo/America/Asuncion b/marketing/share/zoneinfo/America/Asuncion
new file mode 100644
index 0000000000000000000000000000000000000000..f056047f058ee5983f113c9129cb7e3e87633de6
Binary files /dev/null and b/marketing/share/zoneinfo/America/Asuncion differ
diff --git a/marketing/share/zoneinfo/America/Atikokan b/marketing/share/zoneinfo/America/Atikokan
new file mode 100644
index 0000000000000000000000000000000000000000..9154643f4c9189998392afb8a93e2e2eb9eaecf5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Atikokan differ
diff --git a/marketing/share/zoneinfo/America/Atka b/marketing/share/zoneinfo/America/Atka
new file mode 100644
index 0000000000000000000000000000000000000000..b1497bda631efdcb6635ffb6b0ee6f7da9e2a280
Binary files /dev/null and b/marketing/share/zoneinfo/America/Atka differ
diff --git a/marketing/share/zoneinfo/America/Bahia b/marketing/share/zoneinfo/America/Bahia
new file mode 100644
index 0000000000000000000000000000000000000000..7969e3076687a35835653a348f0f3c8c0b2e1821
Binary files /dev/null and b/marketing/share/zoneinfo/America/Bahia differ
diff --git a/marketing/share/zoneinfo/America/Bahia_Banderas b/marketing/share/zoneinfo/America/Bahia_Banderas
new file mode 100644
index 0000000000000000000000000000000000000000..882400bd33bdc23fc75b092a01ea935b02431715
Binary files /dev/null and b/marketing/share/zoneinfo/America/Bahia_Banderas differ
diff --git a/marketing/share/zoneinfo/America/Barbados b/marketing/share/zoneinfo/America/Barbados
new file mode 100644
index 0000000000000000000000000000000000000000..720c9863f2a834f310280cc9113bedc59a25206d
Binary files /dev/null and b/marketing/share/zoneinfo/America/Barbados differ
diff --git a/marketing/share/zoneinfo/America/Belem b/marketing/share/zoneinfo/America/Belem
new file mode 100644
index 0000000000000000000000000000000000000000..e0d7653c64c1e3b3e546d4c5e7644865b237f128
Binary files /dev/null and b/marketing/share/zoneinfo/America/Belem differ
diff --git a/marketing/share/zoneinfo/America/Belize b/marketing/share/zoneinfo/America/Belize
new file mode 100644
index 0000000000000000000000000000000000000000..bfc19f4e587cadf6a2b05781860c21dccdf02961
Binary files /dev/null and b/marketing/share/zoneinfo/America/Belize differ
diff --git a/marketing/share/zoneinfo/America/Blanc-Sablon b/marketing/share/zoneinfo/America/Blanc-Sablon
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Blanc-Sablon differ
diff --git a/marketing/share/zoneinfo/America/Boa_Vista b/marketing/share/zoneinfo/America/Boa_Vista
new file mode 100644
index 0000000000000000000000000000000000000000..fca97207b2833031d00d3ff0246d7518b3042644
Binary files /dev/null and b/marketing/share/zoneinfo/America/Boa_Vista differ
diff --git a/marketing/share/zoneinfo/America/Bogota b/marketing/share/zoneinfo/America/Bogota
new file mode 100644
index 0000000000000000000000000000000000000000..85b903333eb6325aa8343f6e9aee38447495303f
Binary files /dev/null and b/marketing/share/zoneinfo/America/Bogota differ
diff --git a/marketing/share/zoneinfo/America/Boise b/marketing/share/zoneinfo/America/Boise
new file mode 100644
index 0000000000000000000000000000000000000000..72fec9e8c52ab8bb3dc6519b9d7f0c311900ac16
Binary files /dev/null and b/marketing/share/zoneinfo/America/Boise differ
diff --git a/marketing/share/zoneinfo/America/Buenos_Aires b/marketing/share/zoneinfo/America/Buenos_Aires
new file mode 100644
index 0000000000000000000000000000000000000000..d6f999b8605c9f73653a16e2ddbd5a49b96c0f56
Binary files /dev/null and b/marketing/share/zoneinfo/America/Buenos_Aires differ
diff --git a/marketing/share/zoneinfo/America/Cambridge_Bay b/marketing/share/zoneinfo/America/Cambridge_Bay
new file mode 100644
index 0000000000000000000000000000000000000000..1092f4b61a1b203f7feabb586b51085bb72602dc
Binary files /dev/null and b/marketing/share/zoneinfo/America/Cambridge_Bay differ
diff --git a/marketing/share/zoneinfo/America/Campo_Grande b/marketing/share/zoneinfo/America/Campo_Grande
new file mode 100644
index 0000000000000000000000000000000000000000..6855e4e9fe021cbbc392c76e1effef86dd53510c
Binary files /dev/null and b/marketing/share/zoneinfo/America/Campo_Grande differ
diff --git a/marketing/share/zoneinfo/America/Cancun b/marketing/share/zoneinfo/America/Cancun
new file mode 100644
index 0000000000000000000000000000000000000000..3110cdfd6e6f4ccd889447657dff43560d5aaee0
Binary files /dev/null and b/marketing/share/zoneinfo/America/Cancun differ
diff --git a/marketing/share/zoneinfo/America/Caracas b/marketing/share/zoneinfo/America/Caracas
new file mode 100644
index 0000000000000000000000000000000000000000..8dbe6ff74127e02577fdccd694af5a61580369e5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Caracas differ
diff --git a/marketing/share/zoneinfo/America/Catamarca b/marketing/share/zoneinfo/America/Catamarca
new file mode 100644
index 0000000000000000000000000000000000000000..1dcc8d85434c9d016f170cb2f16811ebef327b77
Binary files /dev/null and b/marketing/share/zoneinfo/America/Catamarca differ
diff --git a/marketing/share/zoneinfo/America/Cayenne b/marketing/share/zoneinfo/America/Cayenne
new file mode 100644
index 0000000000000000000000000000000000000000..cd49f0534438cc3bfa0e09bb5701552ce9a177cc
Binary files /dev/null and b/marketing/share/zoneinfo/America/Cayenne differ
diff --git a/marketing/share/zoneinfo/America/Cayman b/marketing/share/zoneinfo/America/Cayman
new file mode 100644
index 0000000000000000000000000000000000000000..9154643f4c9189998392afb8a93e2e2eb9eaecf5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Cayman differ
diff --git a/marketing/share/zoneinfo/America/Chicago b/marketing/share/zoneinfo/America/Chicago
new file mode 100644
index 0000000000000000000000000000000000000000..b016880653929aa40dd5ac0e82e4094a9d787cdf
Binary files /dev/null and b/marketing/share/zoneinfo/America/Chicago differ
diff --git a/marketing/share/zoneinfo/America/Chihuahua b/marketing/share/zoneinfo/America/Chihuahua
new file mode 100644
index 0000000000000000000000000000000000000000..f65bb1c9310447737822ad026470d5092ce87678
Binary files /dev/null and b/marketing/share/zoneinfo/America/Chihuahua differ
diff --git a/marketing/share/zoneinfo/America/Ciudad_Juarez b/marketing/share/zoneinfo/America/Ciudad_Juarez
new file mode 100644
index 0000000000000000000000000000000000000000..5f865ea808b57d97634d4331fc5fce84349ded36
Binary files /dev/null and b/marketing/share/zoneinfo/America/Ciudad_Juarez differ
diff --git a/marketing/share/zoneinfo/America/Coral_Harbour b/marketing/share/zoneinfo/America/Coral_Harbour
new file mode 100644
index 0000000000000000000000000000000000000000..9154643f4c9189998392afb8a93e2e2eb9eaecf5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Coral_Harbour differ
diff --git a/marketing/share/zoneinfo/America/Cordoba b/marketing/share/zoneinfo/America/Cordoba
new file mode 100644
index 0000000000000000000000000000000000000000..35a52e53d123b5ef5d293b3af19046630f02bb66
Binary files /dev/null and b/marketing/share/zoneinfo/America/Cordoba differ
diff --git a/marketing/share/zoneinfo/America/Costa_Rica b/marketing/share/zoneinfo/America/Costa_Rica
new file mode 100644
index 0000000000000000000000000000000000000000..08f0128ee681d8f7e1df186d93514f3f4cff2830
Binary files /dev/null and b/marketing/share/zoneinfo/America/Costa_Rica differ
diff --git a/marketing/share/zoneinfo/America/Creston b/marketing/share/zoneinfo/America/Creston
new file mode 100644
index 0000000000000000000000000000000000000000..c2bd2f949b248b835c98216b4dc66f9f6eb0265e
Binary files /dev/null and b/marketing/share/zoneinfo/America/Creston differ
diff --git a/marketing/share/zoneinfo/America/Cuiaba b/marketing/share/zoneinfo/America/Cuiaba
new file mode 100644
index 0000000000000000000000000000000000000000..c09a87558d53b031fca84a4c92165b01b37da360
Binary files /dev/null and b/marketing/share/zoneinfo/America/Cuiaba differ
diff --git a/marketing/share/zoneinfo/America/Curacao b/marketing/share/zoneinfo/America/Curacao
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Curacao differ
diff --git a/marketing/share/zoneinfo/America/Danmarkshavn b/marketing/share/zoneinfo/America/Danmarkshavn
new file mode 100644
index 0000000000000000000000000000000000000000..8718efcce25cd28ff9fa0f48bba0a2a7e6be4ed0
Binary files /dev/null and b/marketing/share/zoneinfo/America/Danmarkshavn differ
diff --git a/marketing/share/zoneinfo/America/Dawson b/marketing/share/zoneinfo/America/Dawson
new file mode 100644
index 0000000000000000000000000000000000000000..07e4c5f4ac3852571b17cb33fe565a5ea2c49f0a
Binary files /dev/null and b/marketing/share/zoneinfo/America/Dawson differ
diff --git a/marketing/share/zoneinfo/America/Dawson_Creek b/marketing/share/zoneinfo/America/Dawson_Creek
new file mode 100644
index 0000000000000000000000000000000000000000..761d1d9af53662efdb521bef949ded15e3f1f4dc
Binary files /dev/null and b/marketing/share/zoneinfo/America/Dawson_Creek differ
diff --git a/marketing/share/zoneinfo/America/Denver b/marketing/share/zoneinfo/America/Denver
new file mode 100644
index 0000000000000000000000000000000000000000..09e54e5c7c5bb2384e37626d4b985cfad29ed29b
Binary files /dev/null and b/marketing/share/zoneinfo/America/Denver differ
diff --git a/marketing/share/zoneinfo/America/Detroit b/marketing/share/zoneinfo/America/Detroit
new file mode 100644
index 0000000000000000000000000000000000000000..6eb3ac46ec56985b52488ae6a8d80247c2adcd4a
Binary files /dev/null and b/marketing/share/zoneinfo/America/Detroit differ
diff --git a/marketing/share/zoneinfo/America/Dominica b/marketing/share/zoneinfo/America/Dominica
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Dominica differ
diff --git a/marketing/share/zoneinfo/America/Edmonton b/marketing/share/zoneinfo/America/Edmonton
new file mode 100644
index 0000000000000000000000000000000000000000..645ee9453073acf4cff9f9420b358a8ebbe40f93
Binary files /dev/null and b/marketing/share/zoneinfo/America/Edmonton differ
diff --git a/marketing/share/zoneinfo/America/Eirunepe b/marketing/share/zoneinfo/America/Eirunepe
new file mode 100644
index 0000000000000000000000000000000000000000..7da4b98fe3c70a1aecae8e0f4264324eaf9e1fb6
Binary files /dev/null and b/marketing/share/zoneinfo/America/Eirunepe differ
diff --git a/marketing/share/zoneinfo/America/El_Salvador b/marketing/share/zoneinfo/America/El_Salvador
new file mode 100644
index 0000000000000000000000000000000000000000..43484117e2858004a0377195b5c83c3a9748062d
Binary files /dev/null and b/marketing/share/zoneinfo/America/El_Salvador differ
diff --git a/marketing/share/zoneinfo/America/Ensenada b/marketing/share/zoneinfo/America/Ensenada
new file mode 100644
index 0000000000000000000000000000000000000000..18d0d14afc1cdf37c8f3607181e3f72211da99e9
Binary files /dev/null and b/marketing/share/zoneinfo/America/Ensenada differ
diff --git a/marketing/share/zoneinfo/America/Fort_Nelson b/marketing/share/zoneinfo/America/Fort_Nelson
new file mode 100644
index 0000000000000000000000000000000000000000..2a49c6c50f4c21765232712d18a6cbbeedafc441
Binary files /dev/null and b/marketing/share/zoneinfo/America/Fort_Nelson differ
diff --git a/marketing/share/zoneinfo/America/Fort_Wayne b/marketing/share/zoneinfo/America/Fort_Wayne
new file mode 100644
index 0000000000000000000000000000000000000000..6b08d15bdaba6cf94dcb2681887154f4d265d8ba
Binary files /dev/null and b/marketing/share/zoneinfo/America/Fort_Wayne differ
diff --git a/marketing/share/zoneinfo/America/Fortaleza b/marketing/share/zoneinfo/America/Fortaleza
new file mode 100644
index 0000000000000000000000000000000000000000..092e40d70122f764fd2630957be1d3e32858f6f5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Fortaleza differ
diff --git a/marketing/share/zoneinfo/America/Glace_Bay b/marketing/share/zoneinfo/America/Glace_Bay
new file mode 100644
index 0000000000000000000000000000000000000000..f85eb341575850b353d31b37908f4fa49119a007
Binary files /dev/null and b/marketing/share/zoneinfo/America/Glace_Bay differ
diff --git a/marketing/share/zoneinfo/America/Godthab b/marketing/share/zoneinfo/America/Godthab
new file mode 100644
index 0000000000000000000000000000000000000000..310774ea4fdd1798782a41f905d16e3548cd191e
Binary files /dev/null and b/marketing/share/zoneinfo/America/Godthab differ
diff --git a/marketing/share/zoneinfo/America/Goose_Bay b/marketing/share/zoneinfo/America/Goose_Bay
new file mode 100644
index 0000000000000000000000000000000000000000..e2cc3eefc273c206ab9d88f94660f587932991fc
Binary files /dev/null and b/marketing/share/zoneinfo/America/Goose_Bay differ
diff --git a/marketing/share/zoneinfo/America/Grand_Turk b/marketing/share/zoneinfo/America/Grand_Turk
new file mode 100644
index 0000000000000000000000000000000000000000..9d90e745b04fae51493817b5ba1db5015a39bfda
Binary files /dev/null and b/marketing/share/zoneinfo/America/Grand_Turk differ
diff --git a/marketing/share/zoneinfo/America/Grenada b/marketing/share/zoneinfo/America/Grenada
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Grenada differ
diff --git a/marketing/share/zoneinfo/America/Guadeloupe b/marketing/share/zoneinfo/America/Guadeloupe
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Guadeloupe differ
diff --git a/marketing/share/zoneinfo/America/Guatemala b/marketing/share/zoneinfo/America/Guatemala
new file mode 100644
index 0000000000000000000000000000000000000000..8aa8e588e3cbf963193269ae01eecfafaeb02b50
Binary files /dev/null and b/marketing/share/zoneinfo/America/Guatemala differ
diff --git a/marketing/share/zoneinfo/America/Guayaquil b/marketing/share/zoneinfo/America/Guayaquil
new file mode 100644
index 0000000000000000000000000000000000000000..381ae6c463260d85ce92d6585b6420fed0c096dd
Binary files /dev/null and b/marketing/share/zoneinfo/America/Guayaquil differ
diff --git a/marketing/share/zoneinfo/America/Guyana b/marketing/share/zoneinfo/America/Guyana
new file mode 100644
index 0000000000000000000000000000000000000000..bcc66881c17cebf8767b7a147b1fcf7ab29bbd9f
Binary files /dev/null and b/marketing/share/zoneinfo/America/Guyana differ
diff --git a/marketing/share/zoneinfo/America/Halifax b/marketing/share/zoneinfo/America/Halifax
new file mode 100644
index 0000000000000000000000000000000000000000..9fa850a7d4c36dea84149bc0ea2fcd3581d61a8c
Binary files /dev/null and b/marketing/share/zoneinfo/America/Halifax differ
diff --git a/marketing/share/zoneinfo/America/Havana b/marketing/share/zoneinfo/America/Havana
new file mode 100644
index 0000000000000000000000000000000000000000..e06629d36841463326ff3350bc2f94d0417c3cdd
Binary files /dev/null and b/marketing/share/zoneinfo/America/Havana differ
diff --git a/marketing/share/zoneinfo/America/Hermosillo b/marketing/share/zoneinfo/America/Hermosillo
new file mode 100644
index 0000000000000000000000000000000000000000..ba7b14760d47d1e10241e78e976f0093ada6551b
Binary files /dev/null and b/marketing/share/zoneinfo/America/Hermosillo differ
diff --git a/marketing/share/zoneinfo/America/Indiana/Indianapolis b/marketing/share/zoneinfo/America/Indiana/Indianapolis
new file mode 100644
index 0000000000000000000000000000000000000000..6b08d15bdaba6cf94dcb2681887154f4d265d8ba
Binary files /dev/null and b/marketing/share/zoneinfo/America/Indiana/Indianapolis differ
diff --git a/marketing/share/zoneinfo/America/Indiana/Knox b/marketing/share/zoneinfo/America/Indiana/Knox
new file mode 100644
index 0000000000000000000000000000000000000000..b187d5f8c75685af67913e9360b50ecad19fe6ad
Binary files /dev/null and b/marketing/share/zoneinfo/America/Indiana/Knox differ
diff --git a/marketing/share/zoneinfo/America/Indiana/Marengo b/marketing/share/zoneinfo/America/Indiana/Marengo
new file mode 100644
index 0000000000000000000000000000000000000000..a730fe666b6522026ec2eb74f94616699178a346
Binary files /dev/null and b/marketing/share/zoneinfo/America/Indiana/Marengo differ
diff --git a/marketing/share/zoneinfo/America/Indiana/Petersburg b/marketing/share/zoneinfo/America/Indiana/Petersburg
new file mode 100644
index 0000000000000000000000000000000000000000..341a0235ef488ee623aba36a8b5928122774d2fb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Indiana/Petersburg differ
diff --git a/marketing/share/zoneinfo/America/Indiana/Tell_City b/marketing/share/zoneinfo/America/Indiana/Tell_City
new file mode 100644
index 0000000000000000000000000000000000000000..76e1f6285b552c11ceae9bc6cdbd6a308419b0e8
Binary files /dev/null and b/marketing/share/zoneinfo/America/Indiana/Tell_City differ
diff --git a/marketing/share/zoneinfo/America/Indiana/Vevay b/marketing/share/zoneinfo/America/Indiana/Vevay
new file mode 100644
index 0000000000000000000000000000000000000000..f2acf6cbbd653929e826366aec83f443d11c66e7
Binary files /dev/null and b/marketing/share/zoneinfo/America/Indiana/Vevay differ
diff --git a/marketing/share/zoneinfo/America/Indiana/Vincennes b/marketing/share/zoneinfo/America/Indiana/Vincennes
new file mode 100644
index 0000000000000000000000000000000000000000..c255f89b6da9916832a8b6a9bb7620859ce33d91
Binary files /dev/null and b/marketing/share/zoneinfo/America/Indiana/Vincennes differ
diff --git a/marketing/share/zoneinfo/America/Indiana/Winamac b/marketing/share/zoneinfo/America/Indiana/Winamac
new file mode 100644
index 0000000000000000000000000000000000000000..679d321e3b691b5403d9c9493367651360ea6f15
Binary files /dev/null and b/marketing/share/zoneinfo/America/Indiana/Winamac differ
diff --git a/marketing/share/zoneinfo/America/Indianapolis b/marketing/share/zoneinfo/America/Indianapolis
new file mode 100644
index 0000000000000000000000000000000000000000..6b08d15bdaba6cf94dcb2681887154f4d265d8ba
Binary files /dev/null and b/marketing/share/zoneinfo/America/Indianapolis differ
diff --git a/marketing/share/zoneinfo/America/Inuvik b/marketing/share/zoneinfo/America/Inuvik
new file mode 100644
index 0000000000000000000000000000000000000000..86639f6ecb4c424911e5bdbca81a9e39c86e850c
Binary files /dev/null and b/marketing/share/zoneinfo/America/Inuvik differ
diff --git a/marketing/share/zoneinfo/America/Iqaluit b/marketing/share/zoneinfo/America/Iqaluit
new file mode 100644
index 0000000000000000000000000000000000000000..95e055cb55d19335fa96f1a8d81fb5620f790771
Binary files /dev/null and b/marketing/share/zoneinfo/America/Iqaluit differ
diff --git a/marketing/share/zoneinfo/America/Jamaica b/marketing/share/zoneinfo/America/Jamaica
new file mode 100644
index 0000000000000000000000000000000000000000..be6b1b6f1e77a8f13a7400bcfc10c63a7ee1d55d
Binary files /dev/null and b/marketing/share/zoneinfo/America/Jamaica differ
diff --git a/marketing/share/zoneinfo/America/Jujuy b/marketing/share/zoneinfo/America/Jujuy
new file mode 100644
index 0000000000000000000000000000000000000000..b275f27c0287415674d2ccc850c3d612f4a45b0f
Binary files /dev/null and b/marketing/share/zoneinfo/America/Jujuy differ
diff --git a/marketing/share/zoneinfo/America/Juneau b/marketing/share/zoneinfo/America/Juneau
new file mode 100644
index 0000000000000000000000000000000000000000..e347b369f780629179a5ffd7a256054d901a1ad5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Juneau differ
diff --git a/marketing/share/zoneinfo/America/Kentucky/Louisville b/marketing/share/zoneinfo/America/Kentucky/Louisville
new file mode 100644
index 0000000000000000000000000000000000000000..f2136d6ed41bb7dc0646b91bab366efb46bacb78
Binary files /dev/null and b/marketing/share/zoneinfo/America/Kentucky/Louisville differ
diff --git a/marketing/share/zoneinfo/America/Kentucky/Monticello b/marketing/share/zoneinfo/America/Kentucky/Monticello
new file mode 100644
index 0000000000000000000000000000000000000000..d9f54a18bbe6885a05a7f42a056bc892b7a641e8
Binary files /dev/null and b/marketing/share/zoneinfo/America/Kentucky/Monticello differ
diff --git a/marketing/share/zoneinfo/America/Knox_IN b/marketing/share/zoneinfo/America/Knox_IN
new file mode 100644
index 0000000000000000000000000000000000000000..b187d5f8c75685af67913e9360b50ecad19fe6ad
Binary files /dev/null and b/marketing/share/zoneinfo/America/Knox_IN differ
diff --git a/marketing/share/zoneinfo/America/Kralendijk b/marketing/share/zoneinfo/America/Kralendijk
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Kralendijk differ
diff --git a/marketing/share/zoneinfo/America/La_Paz b/marketing/share/zoneinfo/America/La_Paz
new file mode 100644
index 0000000000000000000000000000000000000000..68ddaae768e665a8170ea1485aae51c686f5cfed
Binary files /dev/null and b/marketing/share/zoneinfo/America/La_Paz differ
diff --git a/marketing/share/zoneinfo/America/Lima b/marketing/share/zoneinfo/America/Lima
new file mode 100644
index 0000000000000000000000000000000000000000..b643c5517f923f075d58897764ba6885197f5758
Binary files /dev/null and b/marketing/share/zoneinfo/America/Lima differ
diff --git a/marketing/share/zoneinfo/America/Los_Angeles b/marketing/share/zoneinfo/America/Los_Angeles
new file mode 100644
index 0000000000000000000000000000000000000000..aaf07787ad92b65eadae63b64bba290f9f961507
Binary files /dev/null and b/marketing/share/zoneinfo/America/Los_Angeles differ
diff --git a/marketing/share/zoneinfo/America/Louisville b/marketing/share/zoneinfo/America/Louisville
new file mode 100644
index 0000000000000000000000000000000000000000..f2136d6ed41bb7dc0646b91bab366efb46bacb78
Binary files /dev/null and b/marketing/share/zoneinfo/America/Louisville differ
diff --git a/marketing/share/zoneinfo/America/Lower_Princes b/marketing/share/zoneinfo/America/Lower_Princes
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Lower_Princes differ
diff --git a/marketing/share/zoneinfo/America/Maceio b/marketing/share/zoneinfo/America/Maceio
new file mode 100644
index 0000000000000000000000000000000000000000..dbb8d57d91d6640c1282fab3a063567d1f663f88
Binary files /dev/null and b/marketing/share/zoneinfo/America/Maceio differ
diff --git a/marketing/share/zoneinfo/America/Managua b/marketing/share/zoneinfo/America/Managua
new file mode 100644
index 0000000000000000000000000000000000000000..86ef76bf2241b6abde0f4790d23b180db4b4b1cc
Binary files /dev/null and b/marketing/share/zoneinfo/America/Managua differ
diff --git a/marketing/share/zoneinfo/America/Manaus b/marketing/share/zoneinfo/America/Manaus
new file mode 100644
index 0000000000000000000000000000000000000000..59c952ebc65169dce30078a3e1ee371e0da52ae4
Binary files /dev/null and b/marketing/share/zoneinfo/America/Manaus differ
diff --git a/marketing/share/zoneinfo/America/Marigot b/marketing/share/zoneinfo/America/Marigot
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Marigot differ
diff --git a/marketing/share/zoneinfo/America/Martinique b/marketing/share/zoneinfo/America/Martinique
new file mode 100644
index 0000000000000000000000000000000000000000..25c0232d95492333e8c1aef7321a24a331e2e24a
Binary files /dev/null and b/marketing/share/zoneinfo/America/Martinique differ
diff --git a/marketing/share/zoneinfo/America/Matamoros b/marketing/share/zoneinfo/America/Matamoros
new file mode 100644
index 0000000000000000000000000000000000000000..993ac47559c154e52af8fba1bcd7c9d0e3bea880
Binary files /dev/null and b/marketing/share/zoneinfo/America/Matamoros differ
diff --git a/marketing/share/zoneinfo/America/Mazatlan b/marketing/share/zoneinfo/America/Mazatlan
new file mode 100644
index 0000000000000000000000000000000000000000..5aa6039ea4cb36077f048782b54c6275c25e86b3
Binary files /dev/null and b/marketing/share/zoneinfo/America/Mazatlan differ
diff --git a/marketing/share/zoneinfo/America/Mendoza b/marketing/share/zoneinfo/America/Mendoza
new file mode 100644
index 0000000000000000000000000000000000000000..691c56978a033586e3302db2ef600e4b0ffd6366
Binary files /dev/null and b/marketing/share/zoneinfo/America/Mendoza differ
diff --git a/marketing/share/zoneinfo/America/Menominee b/marketing/share/zoneinfo/America/Menominee
new file mode 100644
index 0000000000000000000000000000000000000000..28d2c56e1a991556b5aca45108e3415f3ebfe868
Binary files /dev/null and b/marketing/share/zoneinfo/America/Menominee differ
diff --git a/marketing/share/zoneinfo/America/Merida b/marketing/share/zoneinfo/America/Merida
new file mode 100644
index 0000000000000000000000000000000000000000..e5c7d8cc2d2a986374f35561d8b629110b481a66
Binary files /dev/null and b/marketing/share/zoneinfo/America/Merida differ
diff --git a/marketing/share/zoneinfo/America/Metlakatla b/marketing/share/zoneinfo/America/Metlakatla
new file mode 100644
index 0000000000000000000000000000000000000000..71b0eab085dbbb48050d7b6a271ebb1a29fb1926
Binary files /dev/null and b/marketing/share/zoneinfo/America/Metlakatla differ
diff --git a/marketing/share/zoneinfo/America/Mexico_City b/marketing/share/zoneinfo/America/Mexico_City
new file mode 100644
index 0000000000000000000000000000000000000000..18112346129a885b5d5fa27109682b63784f72c0
Binary files /dev/null and b/marketing/share/zoneinfo/America/Mexico_City differ
diff --git a/marketing/share/zoneinfo/America/Miquelon b/marketing/share/zoneinfo/America/Miquelon
new file mode 100644
index 0000000000000000000000000000000000000000..ba95cb0b3f755ab94154a54fd8cf6e6b9cdb0556
Binary files /dev/null and b/marketing/share/zoneinfo/America/Miquelon differ
diff --git a/marketing/share/zoneinfo/America/Moncton b/marketing/share/zoneinfo/America/Moncton
new file mode 100644
index 0000000000000000000000000000000000000000..020e33d976179e8f61a6040caaef3c8eb7f348bc
Binary files /dev/null and b/marketing/share/zoneinfo/America/Moncton differ
diff --git a/marketing/share/zoneinfo/America/Monterrey b/marketing/share/zoneinfo/America/Monterrey
new file mode 100644
index 0000000000000000000000000000000000000000..c1e05464513a451ab3cc49452e39da2b04e01de0
Binary files /dev/null and b/marketing/share/zoneinfo/America/Monterrey differ
diff --git a/marketing/share/zoneinfo/America/Montevideo b/marketing/share/zoneinfo/America/Montevideo
new file mode 100644
index 0000000000000000000000000000000000000000..4b2fb3e560f6ad26b30b2215d26b3d6176d076b2
Binary files /dev/null and b/marketing/share/zoneinfo/America/Montevideo differ
diff --git a/marketing/share/zoneinfo/America/Montreal b/marketing/share/zoneinfo/America/Montreal
new file mode 100644
index 0000000000000000000000000000000000000000..668e70d765dc3fb0eda16fb0f1932af607b53412
Binary files /dev/null and b/marketing/share/zoneinfo/America/Montreal differ
diff --git a/marketing/share/zoneinfo/America/Montserrat b/marketing/share/zoneinfo/America/Montserrat
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Montserrat differ
diff --git a/marketing/share/zoneinfo/America/Nassau b/marketing/share/zoneinfo/America/Nassau
new file mode 100644
index 0000000000000000000000000000000000000000..668e70d765dc3fb0eda16fb0f1932af607b53412
Binary files /dev/null and b/marketing/share/zoneinfo/America/Nassau differ
diff --git a/marketing/share/zoneinfo/America/New_York b/marketing/share/zoneinfo/America/New_York
new file mode 100644
index 0000000000000000000000000000000000000000..2b6c2eea14df07392729ae9f5712a44ec4f02bae
Binary files /dev/null and b/marketing/share/zoneinfo/America/New_York differ
diff --git a/marketing/share/zoneinfo/America/Nipigon b/marketing/share/zoneinfo/America/Nipigon
new file mode 100644
index 0000000000000000000000000000000000000000..668e70d765dc3fb0eda16fb0f1932af607b53412
Binary files /dev/null and b/marketing/share/zoneinfo/America/Nipigon differ
diff --git a/marketing/share/zoneinfo/America/Nome b/marketing/share/zoneinfo/America/Nome
new file mode 100644
index 0000000000000000000000000000000000000000..23ead1c004ffd82c03b69b44e147daef4c07c961
Binary files /dev/null and b/marketing/share/zoneinfo/America/Nome differ
diff --git a/marketing/share/zoneinfo/America/Noronha b/marketing/share/zoneinfo/America/Noronha
new file mode 100644
index 0000000000000000000000000000000000000000..9e74745ca79137918281337fa270c5fec4bd7da1
Binary files /dev/null and b/marketing/share/zoneinfo/America/Noronha differ
diff --git a/marketing/share/zoneinfo/America/North_Dakota/Beulah b/marketing/share/zoneinfo/America/North_Dakota/Beulah
new file mode 100644
index 0000000000000000000000000000000000000000..becf4383301e2d90db0c0c06659b588d25042ee5
Binary files /dev/null and b/marketing/share/zoneinfo/America/North_Dakota/Beulah differ
diff --git a/marketing/share/zoneinfo/America/North_Dakota/Center b/marketing/share/zoneinfo/America/North_Dakota/Center
new file mode 100644
index 0000000000000000000000000000000000000000..d03bda045d31662adc65450b33e9665c54fdb245
Binary files /dev/null and b/marketing/share/zoneinfo/America/North_Dakota/Center differ
diff --git a/marketing/share/zoneinfo/America/North_Dakota/New_Salem b/marketing/share/zoneinfo/America/North_Dakota/New_Salem
new file mode 100644
index 0000000000000000000000000000000000000000..ecefc15d8cdf601347e114ff25b3bb2df4d56a57
Binary files /dev/null and b/marketing/share/zoneinfo/America/North_Dakota/New_Salem differ
diff --git a/marketing/share/zoneinfo/America/Nuuk b/marketing/share/zoneinfo/America/Nuuk
new file mode 100644
index 0000000000000000000000000000000000000000..310774ea4fdd1798782a41f905d16e3548cd191e
Binary files /dev/null and b/marketing/share/zoneinfo/America/Nuuk differ
diff --git a/marketing/share/zoneinfo/America/Ojinaga b/marketing/share/zoneinfo/America/Ojinaga
new file mode 100644
index 0000000000000000000000000000000000000000..1dd08b1cafd4b36ce963bdc42a075665fa723b54
Binary files /dev/null and b/marketing/share/zoneinfo/America/Ojinaga differ
diff --git a/marketing/share/zoneinfo/America/Panama b/marketing/share/zoneinfo/America/Panama
new file mode 100644
index 0000000000000000000000000000000000000000..9154643f4c9189998392afb8a93e2e2eb9eaecf5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Panama differ
diff --git a/marketing/share/zoneinfo/America/Pangnirtung b/marketing/share/zoneinfo/America/Pangnirtung
new file mode 100644
index 0000000000000000000000000000000000000000..95e055cb55d19335fa96f1a8d81fb5620f790771
Binary files /dev/null and b/marketing/share/zoneinfo/America/Pangnirtung differ
diff --git a/marketing/share/zoneinfo/America/Paramaribo b/marketing/share/zoneinfo/America/Paramaribo
new file mode 100644
index 0000000000000000000000000000000000000000..24f925a2dd33d487e41cb38b9c3b4c420af69c1d
Binary files /dev/null and b/marketing/share/zoneinfo/America/Paramaribo differ
diff --git a/marketing/share/zoneinfo/America/Phoenix b/marketing/share/zoneinfo/America/Phoenix
new file mode 100644
index 0000000000000000000000000000000000000000..c2bd2f949b248b835c98216b4dc66f9f6eb0265e
Binary files /dev/null and b/marketing/share/zoneinfo/America/Phoenix differ
diff --git a/marketing/share/zoneinfo/America/Port-au-Prince b/marketing/share/zoneinfo/America/Port-au-Prince
new file mode 100644
index 0000000000000000000000000000000000000000..3e75731baa7c47f2a60ad07733d6f8467ccfbebf
Binary files /dev/null and b/marketing/share/zoneinfo/America/Port-au-Prince differ
diff --git a/marketing/share/zoneinfo/America/Port_of_Spain b/marketing/share/zoneinfo/America/Port_of_Spain
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Port_of_Spain differ
diff --git a/marketing/share/zoneinfo/America/Porto_Acre b/marketing/share/zoneinfo/America/Porto_Acre
new file mode 100644
index 0000000000000000000000000000000000000000..fb5185ca60283bd56f795e9a956274c0b6e63325
Binary files /dev/null and b/marketing/share/zoneinfo/America/Porto_Acre differ
diff --git a/marketing/share/zoneinfo/America/Porto_Velho b/marketing/share/zoneinfo/America/Porto_Velho
new file mode 100644
index 0000000000000000000000000000000000000000..7f8047d9396f92476873c9dbedb4598d9d238046
Binary files /dev/null and b/marketing/share/zoneinfo/America/Porto_Velho differ
diff --git a/marketing/share/zoneinfo/America/Puerto_Rico b/marketing/share/zoneinfo/America/Puerto_Rico
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Puerto_Rico differ
diff --git a/marketing/share/zoneinfo/America/Punta_Arenas b/marketing/share/zoneinfo/America/Punta_Arenas
new file mode 100644
index 0000000000000000000000000000000000000000..aa839ea7d42eb9822002e66322c4ae195f1644b5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Punta_Arenas differ
diff --git a/marketing/share/zoneinfo/America/Rainy_River b/marketing/share/zoneinfo/America/Rainy_River
new file mode 100644
index 0000000000000000000000000000000000000000..7e646d18e18851bfde743b379e52df4ec5b5a20f
Binary files /dev/null and b/marketing/share/zoneinfo/America/Rainy_River differ
diff --git a/marketing/share/zoneinfo/America/Rankin_Inlet b/marketing/share/zoneinfo/America/Rankin_Inlet
new file mode 100644
index 0000000000000000000000000000000000000000..6d1d90dede9888571eb09299dbd0b3e7dcfb1cc9
Binary files /dev/null and b/marketing/share/zoneinfo/America/Rankin_Inlet differ
diff --git a/marketing/share/zoneinfo/America/Recife b/marketing/share/zoneinfo/America/Recife
new file mode 100644
index 0000000000000000000000000000000000000000..305abcb8a2217834e8333a2c486ccd389199a334
Binary files /dev/null and b/marketing/share/zoneinfo/America/Recife differ
diff --git a/marketing/share/zoneinfo/America/Regina b/marketing/share/zoneinfo/America/Regina
new file mode 100644
index 0000000000000000000000000000000000000000..a3f8217a544ebb0993473bbffaae8e2d723c4ec3
Binary files /dev/null and b/marketing/share/zoneinfo/America/Regina differ
diff --git a/marketing/share/zoneinfo/America/Resolute b/marketing/share/zoneinfo/America/Resolute
new file mode 100644
index 0000000000000000000000000000000000000000..97eb8a9c1fbbf56b8e32a1bea34f68e263e2a9d7
Binary files /dev/null and b/marketing/share/zoneinfo/America/Resolute differ
diff --git a/marketing/share/zoneinfo/America/Rio_Branco b/marketing/share/zoneinfo/America/Rio_Branco
new file mode 100644
index 0000000000000000000000000000000000000000..fb5185ca60283bd56f795e9a956274c0b6e63325
Binary files /dev/null and b/marketing/share/zoneinfo/America/Rio_Branco differ
diff --git a/marketing/share/zoneinfo/America/Rosario b/marketing/share/zoneinfo/America/Rosario
new file mode 100644
index 0000000000000000000000000000000000000000..35a52e53d123b5ef5d293b3af19046630f02bb66
Binary files /dev/null and b/marketing/share/zoneinfo/America/Rosario differ
diff --git a/marketing/share/zoneinfo/America/Santa_Isabel b/marketing/share/zoneinfo/America/Santa_Isabel
new file mode 100644
index 0000000000000000000000000000000000000000..18d0d14afc1cdf37c8f3607181e3f72211da99e9
Binary files /dev/null and b/marketing/share/zoneinfo/America/Santa_Isabel differ
diff --git a/marketing/share/zoneinfo/America/Santarem b/marketing/share/zoneinfo/America/Santarem
new file mode 100644
index 0000000000000000000000000000000000000000..f81d144206ac5bd2029d59beac0bb82801ebe67a
Binary files /dev/null and b/marketing/share/zoneinfo/America/Santarem differ
diff --git a/marketing/share/zoneinfo/America/Santiago b/marketing/share/zoneinfo/America/Santiago
new file mode 100644
index 0000000000000000000000000000000000000000..d3fc9b8343369abf5f14be781397f426c5969608
Binary files /dev/null and b/marketing/share/zoneinfo/America/Santiago differ
diff --git a/marketing/share/zoneinfo/America/Santo_Domingo b/marketing/share/zoneinfo/America/Santo_Domingo
new file mode 100644
index 0000000000000000000000000000000000000000..3e0785086639e483597890d2b53b9bc4c4ccfe91
Binary files /dev/null and b/marketing/share/zoneinfo/America/Santo_Domingo differ
diff --git a/marketing/share/zoneinfo/America/Sao_Paulo b/marketing/share/zoneinfo/America/Sao_Paulo
new file mode 100644
index 0000000000000000000000000000000000000000..a16da2c4d5a980cd944d86c34ea8a2f597e39b71
Binary files /dev/null and b/marketing/share/zoneinfo/America/Sao_Paulo differ
diff --git a/marketing/share/zoneinfo/America/Scoresbysund b/marketing/share/zoneinfo/America/Scoresbysund
new file mode 100644
index 0000000000000000000000000000000000000000..fc1b11cbe876cabb53fc1d42db25b0aabd967fc0
Binary files /dev/null and b/marketing/share/zoneinfo/America/Scoresbysund differ
diff --git a/marketing/share/zoneinfo/America/Shiprock b/marketing/share/zoneinfo/America/Shiprock
new file mode 100644
index 0000000000000000000000000000000000000000..09e54e5c7c5bb2384e37626d4b985cfad29ed29b
Binary files /dev/null and b/marketing/share/zoneinfo/America/Shiprock differ
diff --git a/marketing/share/zoneinfo/America/Sitka b/marketing/share/zoneinfo/America/Sitka
new file mode 100644
index 0000000000000000000000000000000000000000..36681ed78eaf0b46f8d142884cf7ae8903a18907
Binary files /dev/null and b/marketing/share/zoneinfo/America/Sitka differ
diff --git a/marketing/share/zoneinfo/America/St_Barthelemy b/marketing/share/zoneinfo/America/St_Barthelemy
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/St_Barthelemy differ
diff --git a/marketing/share/zoneinfo/America/St_Johns b/marketing/share/zoneinfo/America/St_Johns
new file mode 100644
index 0000000000000000000000000000000000000000..94d790baaccb72298bb577041cf3c8400339a7da
Binary files /dev/null and b/marketing/share/zoneinfo/America/St_Johns differ
diff --git a/marketing/share/zoneinfo/America/St_Kitts b/marketing/share/zoneinfo/America/St_Kitts
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/St_Kitts differ
diff --git a/marketing/share/zoneinfo/America/St_Lucia b/marketing/share/zoneinfo/America/St_Lucia
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/St_Lucia differ
diff --git a/marketing/share/zoneinfo/America/St_Thomas b/marketing/share/zoneinfo/America/St_Thomas
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/St_Thomas differ
diff --git a/marketing/share/zoneinfo/America/St_Vincent b/marketing/share/zoneinfo/America/St_Vincent
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/St_Vincent differ
diff --git a/marketing/share/zoneinfo/America/Swift_Current b/marketing/share/zoneinfo/America/Swift_Current
new file mode 100644
index 0000000000000000000000000000000000000000..bdbb494487de8aeb624c950e470ebba223d16961
Binary files /dev/null and b/marketing/share/zoneinfo/America/Swift_Current differ
diff --git a/marketing/share/zoneinfo/America/Tegucigalpa b/marketing/share/zoneinfo/America/Tegucigalpa
new file mode 100644
index 0000000000000000000000000000000000000000..38036a32831d149c6c737dfa49f0947f066288b1
Binary files /dev/null and b/marketing/share/zoneinfo/America/Tegucigalpa differ
diff --git a/marketing/share/zoneinfo/America/Thule b/marketing/share/zoneinfo/America/Thule
new file mode 100644
index 0000000000000000000000000000000000000000..f38dc56bf20d9db68515ea7602c9edb39fabae8d
Binary files /dev/null and b/marketing/share/zoneinfo/America/Thule differ
diff --git a/marketing/share/zoneinfo/America/Thunder_Bay b/marketing/share/zoneinfo/America/Thunder_Bay
new file mode 100644
index 0000000000000000000000000000000000000000..668e70d765dc3fb0eda16fb0f1932af607b53412
Binary files /dev/null and b/marketing/share/zoneinfo/America/Thunder_Bay differ
diff --git a/marketing/share/zoneinfo/America/Tijuana b/marketing/share/zoneinfo/America/Tijuana
new file mode 100644
index 0000000000000000000000000000000000000000..18d0d14afc1cdf37c8f3607181e3f72211da99e9
Binary files /dev/null and b/marketing/share/zoneinfo/America/Tijuana differ
diff --git a/marketing/share/zoneinfo/America/Toronto b/marketing/share/zoneinfo/America/Toronto
new file mode 100644
index 0000000000000000000000000000000000000000..668e70d765dc3fb0eda16fb0f1932af607b53412
Binary files /dev/null and b/marketing/share/zoneinfo/America/Toronto differ
diff --git a/marketing/share/zoneinfo/America/Tortola b/marketing/share/zoneinfo/America/Tortola
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Tortola differ
diff --git a/marketing/share/zoneinfo/America/Vancouver b/marketing/share/zoneinfo/America/Vancouver
new file mode 100644
index 0000000000000000000000000000000000000000..c998491112ea5e4430b8266498cf7f23e1266bc5
Binary files /dev/null and b/marketing/share/zoneinfo/America/Vancouver differ
diff --git a/marketing/share/zoneinfo/America/Virgin b/marketing/share/zoneinfo/America/Virgin
new file mode 100644
index 0000000000000000000000000000000000000000..47b4dc34160dd3ff97ebc35ccdc99fcf49c7ffbb
Binary files /dev/null and b/marketing/share/zoneinfo/America/Virgin differ
diff --git a/marketing/share/zoneinfo/America/Whitehorse b/marketing/share/zoneinfo/America/Whitehorse
new file mode 100644
index 0000000000000000000000000000000000000000..40baa9aba2a879f7a38a5a0f67e16e7a2d677a5e
Binary files /dev/null and b/marketing/share/zoneinfo/America/Whitehorse differ
diff --git a/marketing/share/zoneinfo/America/Winnipeg b/marketing/share/zoneinfo/America/Winnipeg
new file mode 100644
index 0000000000000000000000000000000000000000..7e646d18e18851bfde743b379e52df4ec5b5a20f
Binary files /dev/null and b/marketing/share/zoneinfo/America/Winnipeg differ
diff --git a/marketing/share/zoneinfo/America/Yakutat b/marketing/share/zoneinfo/America/Yakutat
new file mode 100644
index 0000000000000000000000000000000000000000..773feba89d36ffab4baf105b8f0ae69584a74014
Binary files /dev/null and b/marketing/share/zoneinfo/America/Yakutat differ
diff --git a/marketing/share/zoneinfo/America/Yellowknife b/marketing/share/zoneinfo/America/Yellowknife
new file mode 100644
index 0000000000000000000000000000000000000000..645ee9453073acf4cff9f9420b358a8ebbe40f93
Binary files /dev/null and b/marketing/share/zoneinfo/America/Yellowknife differ
diff --git a/marketing/share/zoneinfo/Antarctica/Casey b/marketing/share/zoneinfo/Antarctica/Casey
new file mode 100644
index 0000000000000000000000000000000000000000..84f1c61e5c7c35090fd2e628e307cff72389fb02
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/Casey differ
diff --git a/marketing/share/zoneinfo/Antarctica/Davis b/marketing/share/zoneinfo/Antarctica/Davis
new file mode 100644
index 0000000000000000000000000000000000000000..3ec32224f2982db46a19d1a159f9017286fd1413
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/Davis differ
diff --git a/marketing/share/zoneinfo/Antarctica/DumontDUrville b/marketing/share/zoneinfo/Antarctica/DumontDUrville
new file mode 100644
index 0000000000000000000000000000000000000000..5d8fc3a1b253d1df3a0184013469c6e46f6f6f75
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/DumontDUrville differ
diff --git a/marketing/share/zoneinfo/Antarctica/Macquarie b/marketing/share/zoneinfo/Antarctica/Macquarie
new file mode 100644
index 0000000000000000000000000000000000000000..99a8e60edffca85f5caf8eda9d05d85a4978e665
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/Macquarie differ
diff --git a/marketing/share/zoneinfo/Antarctica/Mawson b/marketing/share/zoneinfo/Antarctica/Mawson
new file mode 100644
index 0000000000000000000000000000000000000000..05e4c6c5867330a5af95cd6816ade311a0cac82d
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/Mawson differ
diff --git a/marketing/share/zoneinfo/Antarctica/McMurdo b/marketing/share/zoneinfo/Antarctica/McMurdo
new file mode 100644
index 0000000000000000000000000000000000000000..afb3929318475d4f0ea9d6c9e94d0f5f81d8b82e
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/McMurdo differ
diff --git a/marketing/share/zoneinfo/Antarctica/Palmer b/marketing/share/zoneinfo/Antarctica/Palmer
new file mode 100644
index 0000000000000000000000000000000000000000..32c1941634aec9e7721fcf8e9b323e7d99c7f337
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/Palmer differ
diff --git a/marketing/share/zoneinfo/Antarctica/Rothera b/marketing/share/zoneinfo/Antarctica/Rothera
new file mode 100644
index 0000000000000000000000000000000000000000..ea49c00b2240fbd608425793b225d6e10a58ddef
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/Rothera differ
diff --git a/marketing/share/zoneinfo/Antarctica/South_Pole b/marketing/share/zoneinfo/Antarctica/South_Pole
new file mode 100644
index 0000000000000000000000000000000000000000..afb3929318475d4f0ea9d6c9e94d0f5f81d8b82e
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/South_Pole differ
diff --git a/marketing/share/zoneinfo/Antarctica/Syowa b/marketing/share/zoneinfo/Antarctica/Syowa
new file mode 100644
index 0000000000000000000000000000000000000000..01c47ccb86ccbde2bf9ad0803298e8df87178a34
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/Syowa differ
diff --git a/marketing/share/zoneinfo/Antarctica/Troll b/marketing/share/zoneinfo/Antarctica/Troll
new file mode 100644
index 0000000000000000000000000000000000000000..2359c44bd00ed44d2cdbf4f0aa0d9cea507814ed
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/Troll differ
diff --git a/marketing/share/zoneinfo/Antarctica/Vostok b/marketing/share/zoneinfo/Antarctica/Vostok
new file mode 100644
index 0000000000000000000000000000000000000000..4ce8f74784e970731f5f44b84f73780087890fa5
Binary files /dev/null and b/marketing/share/zoneinfo/Antarctica/Vostok differ
diff --git a/marketing/share/zoneinfo/Arctic/Longyearbyen b/marketing/share/zoneinfo/Arctic/Longyearbyen
new file mode 100644
index 0000000000000000000000000000000000000000..465546bd396ae5eb75076f13ba9c29b0c926c835
Binary files /dev/null and b/marketing/share/zoneinfo/Arctic/Longyearbyen differ
diff --git a/marketing/share/zoneinfo/Asia/Aden b/marketing/share/zoneinfo/Asia/Aden
new file mode 100644
index 0000000000000000000000000000000000000000..01c47ccb86ccbde2bf9ad0803298e8df87178a34
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Aden differ
diff --git a/marketing/share/zoneinfo/Asia/Almaty b/marketing/share/zoneinfo/Asia/Almaty
new file mode 100644
index 0000000000000000000000000000000000000000..02f047d70fc811f8cc17f2c08ddc1f328576fb94
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Almaty differ
diff --git a/marketing/share/zoneinfo/Asia/Amman b/marketing/share/zoneinfo/Asia/Amman
new file mode 100644
index 0000000000000000000000000000000000000000..a3f9dff57148554c4207d71df64851aee2b28b19
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Amman differ
diff --git a/marketing/share/zoneinfo/Asia/Anadyr b/marketing/share/zoneinfo/Asia/Anadyr
new file mode 100644
index 0000000000000000000000000000000000000000..551884d322bcd2201b4b9898ec765141277e6eee
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Anadyr differ
diff --git a/marketing/share/zoneinfo/Asia/Aqtau b/marketing/share/zoneinfo/Asia/Aqtau
new file mode 100644
index 0000000000000000000000000000000000000000..3a40d1175a7d81d8a307d0e546a1fe9a40888b29
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Aqtau differ
diff --git a/marketing/share/zoneinfo/Asia/Aqtobe b/marketing/share/zoneinfo/Asia/Aqtobe
new file mode 100644
index 0000000000000000000000000000000000000000..62c5840a83e29b4fcedba95e438581cec96b3cf6
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Aqtobe differ
diff --git a/marketing/share/zoneinfo/Asia/Ashgabat b/marketing/share/zoneinfo/Asia/Ashgabat
new file mode 100644
index 0000000000000000000000000000000000000000..8482167269080ead3a6046ae5e64b56d48dac1dd
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Ashgabat differ
diff --git a/marketing/share/zoneinfo/Asia/Ashkhabad b/marketing/share/zoneinfo/Asia/Ashkhabad
new file mode 100644
index 0000000000000000000000000000000000000000..8482167269080ead3a6046ae5e64b56d48dac1dd
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Ashkhabad differ
diff --git a/marketing/share/zoneinfo/Asia/Atyrau b/marketing/share/zoneinfo/Asia/Atyrau
new file mode 100644
index 0000000000000000000000000000000000000000..cb2c82f657c7380462b3ea38d5e58cc3d692e0b2
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Atyrau differ
diff --git a/marketing/share/zoneinfo/Asia/Baghdad b/marketing/share/zoneinfo/Asia/Baghdad
new file mode 100644
index 0000000000000000000000000000000000000000..a3ce97599100c0e514afa0764879c3f104be87e9
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Baghdad differ
diff --git a/marketing/share/zoneinfo/Asia/Bahrain b/marketing/share/zoneinfo/Asia/Bahrain
new file mode 100644
index 0000000000000000000000000000000000000000..7409d74983c8d0cd8347a663c3bfbc1c041124da
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Bahrain differ
diff --git a/marketing/share/zoneinfo/Asia/Baku b/marketing/share/zoneinfo/Asia/Baku
new file mode 100644
index 0000000000000000000000000000000000000000..96203d7a4266cd8646032165950374761090e318
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Baku differ
diff --git a/marketing/share/zoneinfo/Asia/Bangkok b/marketing/share/zoneinfo/Asia/Bangkok
new file mode 100644
index 0000000000000000000000000000000000000000..ed687d2985c208171adcaa3401496b05325edca4
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Bangkok differ
diff --git a/marketing/share/zoneinfo/Asia/Barnaul b/marketing/share/zoneinfo/Asia/Barnaul
new file mode 100644
index 0000000000000000000000000000000000000000..ff976dd3b27ac5f14dcbac2362f1b4638c5684aa
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Barnaul differ
diff --git a/marketing/share/zoneinfo/Asia/Beirut b/marketing/share/zoneinfo/Asia/Beirut
new file mode 100644
index 0000000000000000000000000000000000000000..55dce5722cc9d913164747da068f37d3529e799f
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Beirut differ
diff --git a/marketing/share/zoneinfo/Asia/Bishkek b/marketing/share/zoneinfo/Asia/Bishkek
new file mode 100644
index 0000000000000000000000000000000000000000..fe7832cdf99ed9da3b64e3b8f6c5cd0b8b4c8de7
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Bishkek differ
diff --git a/marketing/share/zoneinfo/Asia/Brunei b/marketing/share/zoneinfo/Asia/Brunei
new file mode 100644
index 0000000000000000000000000000000000000000..59bc6e40b7bb0b4eb199dd8c17f416ee00ca4158
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Brunei differ
diff --git a/marketing/share/zoneinfo/Asia/Calcutta b/marketing/share/zoneinfo/Asia/Calcutta
new file mode 100644
index 0000000000000000000000000000000000000000..00bc80a65e9a7aa470d63fba1ce1b29ef173d922
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Calcutta differ
diff --git a/marketing/share/zoneinfo/Asia/Chita b/marketing/share/zoneinfo/Asia/Chita
new file mode 100644
index 0000000000000000000000000000000000000000..9d49cd35cd5e52c5ff0f2c0cc6bd3f4f6e856915
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Chita differ
diff --git a/marketing/share/zoneinfo/Asia/Choibalsan b/marketing/share/zoneinfo/Asia/Choibalsan
new file mode 100644
index 0000000000000000000000000000000000000000..6f5d3a15abbe48b8a4dc72aadc88c416160a56a6
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Choibalsan differ
diff --git a/marketing/share/zoneinfo/Asia/Chongqing b/marketing/share/zoneinfo/Asia/Chongqing
new file mode 100644
index 0000000000000000000000000000000000000000..d6b66984a2f36ae36b35e174756707aa7286c292
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Chongqing differ
diff --git a/marketing/share/zoneinfo/Asia/Chungking b/marketing/share/zoneinfo/Asia/Chungking
new file mode 100644
index 0000000000000000000000000000000000000000..d6b66984a2f36ae36b35e174756707aa7286c292
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Chungking differ
diff --git a/marketing/share/zoneinfo/Asia/Colombo b/marketing/share/zoneinfo/Asia/Colombo
new file mode 100644
index 0000000000000000000000000000000000000000..3eeb1b72b68993e26a2452afe98a6420ac66bafb
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Colombo differ
diff --git a/marketing/share/zoneinfo/Asia/Dacca b/marketing/share/zoneinfo/Asia/Dacca
new file mode 100644
index 0000000000000000000000000000000000000000..28136808b6d1029676448d8711265d8c55cb4bae
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Dacca differ
diff --git a/marketing/share/zoneinfo/Asia/Damascus b/marketing/share/zoneinfo/Asia/Damascus
new file mode 100644
index 0000000000000000000000000000000000000000..bd1624de5148d5670e4585dfcb445d8b270c02df
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Damascus differ
diff --git a/marketing/share/zoneinfo/Asia/Dhaka b/marketing/share/zoneinfo/Asia/Dhaka
new file mode 100644
index 0000000000000000000000000000000000000000..28136808b6d1029676448d8711265d8c55cb4bae
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Dhaka differ
diff --git a/marketing/share/zoneinfo/Asia/Dili b/marketing/share/zoneinfo/Asia/Dili
new file mode 100644
index 0000000000000000000000000000000000000000..22e705ca1ab1218e9f36b9f4f607258389853c8b
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Dili differ
diff --git a/marketing/share/zoneinfo/Asia/Dubai b/marketing/share/zoneinfo/Asia/Dubai
new file mode 100644
index 0000000000000000000000000000000000000000..58d75bc26eec90272e97696f40483eb56c2b8b45
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Dubai differ
diff --git a/marketing/share/zoneinfo/Asia/Dushanbe b/marketing/share/zoneinfo/Asia/Dushanbe
new file mode 100644
index 0000000000000000000000000000000000000000..d83fb076a256817ca0a3ec4e43c7768e6680dc84
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Dushanbe differ
diff --git a/marketing/share/zoneinfo/Asia/Famagusta b/marketing/share/zoneinfo/Asia/Famagusta
new file mode 100644
index 0000000000000000000000000000000000000000..cc44179564afe36db0f1f7aab0a19cbc3e4fa4d0
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Famagusta differ
diff --git a/marketing/share/zoneinfo/Asia/Gaza b/marketing/share/zoneinfo/Asia/Gaza
new file mode 100644
index 0000000000000000000000000000000000000000..0d79662716b445f61e5577bdb09e7c91e4a40d28
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Gaza differ
diff --git a/marketing/share/zoneinfo/Asia/Harbin b/marketing/share/zoneinfo/Asia/Harbin
new file mode 100644
index 0000000000000000000000000000000000000000..d6b66984a2f36ae36b35e174756707aa7286c292
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Harbin differ
diff --git a/marketing/share/zoneinfo/Asia/Hebron b/marketing/share/zoneinfo/Asia/Hebron
new file mode 100644
index 0000000000000000000000000000000000000000..53a3c14312bc770bf9bca1d2e7518763fec7a485
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Hebron differ
diff --git a/marketing/share/zoneinfo/Asia/Ho_Chi_Minh b/marketing/share/zoneinfo/Asia/Ho_Chi_Minh
new file mode 100644
index 0000000000000000000000000000000000000000..86e21b0f524426287fb3b21a82369283c4040c0e
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Ho_Chi_Minh differ
diff --git a/marketing/share/zoneinfo/Asia/Hong_Kong b/marketing/share/zoneinfo/Asia/Hong_Kong
new file mode 100644
index 0000000000000000000000000000000000000000..c80e364801be87687625f72e8e2c3dbd0f7ae4bc
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Hong_Kong differ
diff --git a/marketing/share/zoneinfo/Asia/Hovd b/marketing/share/zoneinfo/Asia/Hovd
new file mode 100644
index 0000000000000000000000000000000000000000..6e08a261274e48f93eb5e221ba294e54ca671b94
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Hovd differ
diff --git a/marketing/share/zoneinfo/Asia/Irkutsk b/marketing/share/zoneinfo/Asia/Irkutsk
new file mode 100644
index 0000000000000000000000000000000000000000..550e2a08773b328683ab10fb9feddee2038e9e58
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Irkutsk differ
diff --git a/marketing/share/zoneinfo/Asia/Istanbul b/marketing/share/zoneinfo/Asia/Istanbul
new file mode 100644
index 0000000000000000000000000000000000000000..c89186687300068ac4e8505cc0012a1dbf6a9960
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Istanbul differ
diff --git a/marketing/share/zoneinfo/Asia/Jakarta b/marketing/share/zoneinfo/Asia/Jakarta
new file mode 100644
index 0000000000000000000000000000000000000000..c9752d2f23ebbb8b1ca5b8ac604c6f24be5d0def
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Jakarta differ
diff --git a/marketing/share/zoneinfo/Asia/Jayapura b/marketing/share/zoneinfo/Asia/Jayapura
new file mode 100644
index 0000000000000000000000000000000000000000..7c22f539d948e5757a0847892da344309b582473
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Jayapura differ
diff --git a/marketing/share/zoneinfo/Asia/Jerusalem b/marketing/share/zoneinfo/Asia/Jerusalem
new file mode 100644
index 0000000000000000000000000000000000000000..4c49bbf52440631eca750cacb7d79f259eeb8bd2
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Jerusalem differ
diff --git a/marketing/share/zoneinfo/Asia/Kabul b/marketing/share/zoneinfo/Asia/Kabul
new file mode 100644
index 0000000000000000000000000000000000000000..660ce4cf695702ee8c6eef5c0e2419de37d6df74
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Kabul differ
diff --git a/marketing/share/zoneinfo/Asia/Kamchatka b/marketing/share/zoneinfo/Asia/Kamchatka
new file mode 100644
index 0000000000000000000000000000000000000000..c65155402db6a465c05a8cd71ec7a0fc0f792762
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Kamchatka differ
diff --git a/marketing/share/zoneinfo/Asia/Karachi b/marketing/share/zoneinfo/Asia/Karachi
new file mode 100644
index 0000000000000000000000000000000000000000..e56d5afdafb27c656a39e1dcdf1e3d2b880efa87
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Karachi differ
diff --git a/marketing/share/zoneinfo/Asia/Kashgar b/marketing/share/zoneinfo/Asia/Kashgar
new file mode 100644
index 0000000000000000000000000000000000000000..69ff7f6fb4973efb1185cad9f553f8c770c75934
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Kashgar differ
diff --git a/marketing/share/zoneinfo/Asia/Kathmandu b/marketing/share/zoneinfo/Asia/Kathmandu
new file mode 100644
index 0000000000000000000000000000000000000000..3a0d330ffd2f08396290960527fc8fc186356161
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Kathmandu differ
diff --git a/marketing/share/zoneinfo/Asia/Katmandu b/marketing/share/zoneinfo/Asia/Katmandu
new file mode 100644
index 0000000000000000000000000000000000000000..3a0d330ffd2f08396290960527fc8fc186356161
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Katmandu differ
diff --git a/marketing/share/zoneinfo/Asia/Khandyga b/marketing/share/zoneinfo/Asia/Khandyga
new file mode 100644
index 0000000000000000000000000000000000000000..aeb733202acd5d9d2a19a54fc64c226302887423
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Khandyga differ
diff --git a/marketing/share/zoneinfo/Asia/Kolkata b/marketing/share/zoneinfo/Asia/Kolkata
new file mode 100644
index 0000000000000000000000000000000000000000..00bc80a65e9a7aa470d63fba1ce1b29ef173d922
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Kolkata differ
diff --git a/marketing/share/zoneinfo/Asia/Krasnoyarsk b/marketing/share/zoneinfo/Asia/Krasnoyarsk
new file mode 100644
index 0000000000000000000000000000000000000000..e0d4fcb5c3d781943a65dc53cca9fab5d1905f9f
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Krasnoyarsk differ
diff --git a/marketing/share/zoneinfo/Asia/Kuala_Lumpur b/marketing/share/zoneinfo/Asia/Kuala_Lumpur
new file mode 100644
index 0000000000000000000000000000000000000000..dbbdea3c8149004cfd525a0fc26e5da72b20e8a1
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Kuala_Lumpur differ
diff --git a/marketing/share/zoneinfo/Asia/Kuching b/marketing/share/zoneinfo/Asia/Kuching
new file mode 100644
index 0000000000000000000000000000000000000000..59bc6e40b7bb0b4eb199dd8c17f416ee00ca4158
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Kuching differ
diff --git a/marketing/share/zoneinfo/Asia/Kuwait b/marketing/share/zoneinfo/Asia/Kuwait
new file mode 100644
index 0000000000000000000000000000000000000000..01c47ccb86ccbde2bf9ad0803298e8df87178a34
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Kuwait differ
diff --git a/marketing/share/zoneinfo/Asia/Macao b/marketing/share/zoneinfo/Asia/Macao
new file mode 100644
index 0000000000000000000000000000000000000000..c22f75e42db6b12db3c837056436cb77d176b83e
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Macao differ
diff --git a/marketing/share/zoneinfo/Asia/Macau b/marketing/share/zoneinfo/Asia/Macau
new file mode 100644
index 0000000000000000000000000000000000000000..c22f75e42db6b12db3c837056436cb77d176b83e
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Macau differ
diff --git a/marketing/share/zoneinfo/Asia/Magadan b/marketing/share/zoneinfo/Asia/Magadan
new file mode 100644
index 0000000000000000000000000000000000000000..16bac8444656c393288dcc0209a96c7c3f487a19
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Magadan differ
diff --git a/marketing/share/zoneinfo/Asia/Makassar b/marketing/share/zoneinfo/Asia/Makassar
new file mode 100644
index 0000000000000000000000000000000000000000..5990010b649745369501c7641c401bcad4345b85
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Makassar differ
diff --git a/marketing/share/zoneinfo/Asia/Manila b/marketing/share/zoneinfo/Asia/Manila
new file mode 100644
index 0000000000000000000000000000000000000000..145bb6fb162e192da18e0991c00578d43475b384
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Manila differ
diff --git a/marketing/share/zoneinfo/Asia/Muscat b/marketing/share/zoneinfo/Asia/Muscat
new file mode 100644
index 0000000000000000000000000000000000000000..58d75bc26eec90272e97696f40483eb56c2b8b45
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Muscat differ
diff --git a/marketing/share/zoneinfo/Asia/Nicosia b/marketing/share/zoneinfo/Asia/Nicosia
new file mode 100644
index 0000000000000000000000000000000000000000..390347f442a486e296689c189e3346695bba5105
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Nicosia differ
diff --git a/marketing/share/zoneinfo/Asia/Novokuznetsk b/marketing/share/zoneinfo/Asia/Novokuznetsk
new file mode 100644
index 0000000000000000000000000000000000000000..9378d50539dfa8f1dabcb40d3720f64906d36202
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Novokuznetsk differ
diff --git a/marketing/share/zoneinfo/Asia/Novosibirsk b/marketing/share/zoneinfo/Asia/Novosibirsk
new file mode 100644
index 0000000000000000000000000000000000000000..65a9fa2cd2e8548b13f1d0895bcba46fa11600a4
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Novosibirsk differ
diff --git a/marketing/share/zoneinfo/Asia/Omsk b/marketing/share/zoneinfo/Asia/Omsk
new file mode 100644
index 0000000000000000000000000000000000000000..dc0ed422f6193fb5d7dcb59dd0eb3e06eec8d4de
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Omsk differ
diff --git a/marketing/share/zoneinfo/Asia/Oral b/marketing/share/zoneinfo/Asia/Oral
new file mode 100644
index 0000000000000000000000000000000000000000..25a63ec8b9951c94fc00a8c6c9d18d2151b26dde
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Oral differ
diff --git a/marketing/share/zoneinfo/Asia/Phnom_Penh b/marketing/share/zoneinfo/Asia/Phnom_Penh
new file mode 100644
index 0000000000000000000000000000000000000000..ed687d2985c208171adcaa3401496b05325edca4
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Phnom_Penh differ
diff --git a/marketing/share/zoneinfo/Asia/Pontianak b/marketing/share/zoneinfo/Asia/Pontianak
new file mode 100644
index 0000000000000000000000000000000000000000..285bed2c63a5debe034a661431d2a1c03dfb0dad
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Pontianak differ
diff --git a/marketing/share/zoneinfo/Asia/Pyongyang b/marketing/share/zoneinfo/Asia/Pyongyang
new file mode 100644
index 0000000000000000000000000000000000000000..57240cf89fb33139a92451ec2eb99cb67b2f49c1
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Pyongyang differ
diff --git a/marketing/share/zoneinfo/Asia/Qatar b/marketing/share/zoneinfo/Asia/Qatar
new file mode 100644
index 0000000000000000000000000000000000000000..7409d74983c8d0cd8347a663c3bfbc1c041124da
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Qatar differ
diff --git a/marketing/share/zoneinfo/Asia/Qostanay b/marketing/share/zoneinfo/Asia/Qostanay
new file mode 100644
index 0000000000000000000000000000000000000000..109fe41562e89a026f828125f960498f62fb5d95
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Qostanay differ
diff --git a/marketing/share/zoneinfo/Asia/Qyzylorda b/marketing/share/zoneinfo/Asia/Qyzylorda
new file mode 100644
index 0000000000000000000000000000000000000000..fe4d6c6d6d44f0f6b7dd1f55702c4d640270a1fc
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Qyzylorda differ
diff --git a/marketing/share/zoneinfo/Asia/Rangoon b/marketing/share/zoneinfo/Asia/Rangoon
new file mode 100644
index 0000000000000000000000000000000000000000..14b2ad09ead50a62d5e2b426396c51f9beb293be
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Rangoon differ
diff --git a/marketing/share/zoneinfo/Asia/Riyadh b/marketing/share/zoneinfo/Asia/Riyadh
new file mode 100644
index 0000000000000000000000000000000000000000..01c47ccb86ccbde2bf9ad0803298e8df87178a34
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Riyadh differ
diff --git a/marketing/share/zoneinfo/Asia/Saigon b/marketing/share/zoneinfo/Asia/Saigon
new file mode 100644
index 0000000000000000000000000000000000000000..86e21b0f524426287fb3b21a82369283c4040c0e
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Saigon differ
diff --git a/marketing/share/zoneinfo/Asia/Sakhalin b/marketing/share/zoneinfo/Asia/Sakhalin
new file mode 100644
index 0000000000000000000000000000000000000000..69f0faad1e7247882721bb81a7242ddd4b1d269f
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Sakhalin differ
diff --git a/marketing/share/zoneinfo/Asia/Samarkand b/marketing/share/zoneinfo/Asia/Samarkand
new file mode 100644
index 0000000000000000000000000000000000000000..c43e27c5d4bd341649b3aa32de068d76618c81ed
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Samarkand differ
diff --git a/marketing/share/zoneinfo/Asia/Seoul b/marketing/share/zoneinfo/Asia/Seoul
new file mode 100644
index 0000000000000000000000000000000000000000..1755147fab44e07b7527ce1eaf3ae991473fb222
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Seoul differ
diff --git a/marketing/share/zoneinfo/Asia/Shanghai b/marketing/share/zoneinfo/Asia/Shanghai
new file mode 100644
index 0000000000000000000000000000000000000000..d6b66984a2f36ae36b35e174756707aa7286c292
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Shanghai differ
diff --git a/marketing/share/zoneinfo/Asia/Singapore b/marketing/share/zoneinfo/Asia/Singapore
new file mode 100644
index 0000000000000000000000000000000000000000..dbbdea3c8149004cfd525a0fc26e5da72b20e8a1
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Singapore differ
diff --git a/marketing/share/zoneinfo/Asia/Srednekolymsk b/marketing/share/zoneinfo/Asia/Srednekolymsk
new file mode 100644
index 0000000000000000000000000000000000000000..7fdee5cbee2b1ba0904a672dde16240404466fb9
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Srednekolymsk differ
diff --git a/marketing/share/zoneinfo/Asia/Taipei b/marketing/share/zoneinfo/Asia/Taipei
new file mode 100644
index 0000000000000000000000000000000000000000..35d89d036d07c3f28dec64092ab1b533c21ae2bc
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Taipei differ
diff --git a/marketing/share/zoneinfo/Asia/Tashkent b/marketing/share/zoneinfo/Asia/Tashkent
new file mode 100644
index 0000000000000000000000000000000000000000..65ee428ce1c5093a4b3dd29512d98a33b4c753a0
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Tashkent differ
diff --git a/marketing/share/zoneinfo/Asia/Tbilisi b/marketing/share/zoneinfo/Asia/Tbilisi
new file mode 100644
index 0000000000000000000000000000000000000000..166e4341d6ce65728367641a467a925800044df6
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Tbilisi differ
diff --git a/marketing/share/zoneinfo/Asia/Tehran b/marketing/share/zoneinfo/Asia/Tehran
new file mode 100644
index 0000000000000000000000000000000000000000..824acb0426faaf659a7f209dda6e1ffd0f3ce2ec
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Tehran differ
diff --git a/marketing/share/zoneinfo/Asia/Tel_Aviv b/marketing/share/zoneinfo/Asia/Tel_Aviv
new file mode 100644
index 0000000000000000000000000000000000000000..4c49bbf52440631eca750cacb7d79f259eeb8bd2
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Tel_Aviv differ
diff --git a/marketing/share/zoneinfo/Asia/Thimbu b/marketing/share/zoneinfo/Asia/Thimbu
new file mode 100644
index 0000000000000000000000000000000000000000..0edc72cfe46b1976bff562929501f202a205d0cc
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Thimbu differ
diff --git a/marketing/share/zoneinfo/Asia/Thimphu b/marketing/share/zoneinfo/Asia/Thimphu
new file mode 100644
index 0000000000000000000000000000000000000000..0edc72cfe46b1976bff562929501f202a205d0cc
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Thimphu differ
diff --git a/marketing/share/zoneinfo/Asia/Tokyo b/marketing/share/zoneinfo/Asia/Tokyo
new file mode 100644
index 0000000000000000000000000000000000000000..1aa066ce38fce7bd0a680f51d6f075718d153a77
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Tokyo differ
diff --git a/marketing/share/zoneinfo/Asia/Tomsk b/marketing/share/zoneinfo/Asia/Tomsk
new file mode 100644
index 0000000000000000000000000000000000000000..c3c307d7b99f39328cf289360526399c55984af6
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Tomsk differ
diff --git a/marketing/share/zoneinfo/Asia/Ujung_Pandang b/marketing/share/zoneinfo/Asia/Ujung_Pandang
new file mode 100644
index 0000000000000000000000000000000000000000..5990010b649745369501c7641c401bcad4345b85
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Ujung_Pandang differ
diff --git a/marketing/share/zoneinfo/Asia/Ulaanbaatar b/marketing/share/zoneinfo/Asia/Ulaanbaatar
new file mode 100644
index 0000000000000000000000000000000000000000..6f5d3a15abbe48b8a4dc72aadc88c416160a56a6
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Ulaanbaatar differ
diff --git a/marketing/share/zoneinfo/Asia/Ulan_Bator b/marketing/share/zoneinfo/Asia/Ulan_Bator
new file mode 100644
index 0000000000000000000000000000000000000000..6f5d3a15abbe48b8a4dc72aadc88c416160a56a6
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Ulan_Bator differ
diff --git a/marketing/share/zoneinfo/Asia/Urumqi b/marketing/share/zoneinfo/Asia/Urumqi
new file mode 100644
index 0000000000000000000000000000000000000000..69ff7f6fb4973efb1185cad9f553f8c770c75934
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Urumqi differ
diff --git a/marketing/share/zoneinfo/Asia/Ust-Nera b/marketing/share/zoneinfo/Asia/Ust-Nera
new file mode 100644
index 0000000000000000000000000000000000000000..c39331e3aa7d7c3c9f38e8ef83e739f0d09194b3
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Ust-Nera differ
diff --git a/marketing/share/zoneinfo/Asia/Vientiane b/marketing/share/zoneinfo/Asia/Vientiane
new file mode 100644
index 0000000000000000000000000000000000000000..ed687d2985c208171adcaa3401496b05325edca4
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Vientiane differ
diff --git a/marketing/share/zoneinfo/Asia/Vladivostok b/marketing/share/zoneinfo/Asia/Vladivostok
new file mode 100644
index 0000000000000000000000000000000000000000..72a3d4e87a0d6f568eeb84b4a9dfae0b679d23ff
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Vladivostok differ
diff --git a/marketing/share/zoneinfo/Asia/Yakutsk b/marketing/share/zoneinfo/Asia/Yakutsk
new file mode 100644
index 0000000000000000000000000000000000000000..336f932e8d458b5096d4aa9483f3177f8d5888eb
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Yakutsk differ
diff --git a/marketing/share/zoneinfo/Asia/Yangon b/marketing/share/zoneinfo/Asia/Yangon
new file mode 100644
index 0000000000000000000000000000000000000000..14b2ad09ead50a62d5e2b426396c51f9beb293be
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Yangon differ
diff --git a/marketing/share/zoneinfo/Asia/Yekaterinburg b/marketing/share/zoneinfo/Asia/Yekaterinburg
new file mode 100644
index 0000000000000000000000000000000000000000..a3bf7f29b6f14debfbd0f8ccb45f1ea338009ef7
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Yekaterinburg differ
diff --git a/marketing/share/zoneinfo/Asia/Yerevan b/marketing/share/zoneinfo/Asia/Yerevan
new file mode 100644
index 0000000000000000000000000000000000000000..6dd927cb94101609afa1d505129296370cd8aabe
Binary files /dev/null and b/marketing/share/zoneinfo/Asia/Yerevan differ
diff --git a/marketing/share/zoneinfo/Atlantic/Azores b/marketing/share/zoneinfo/Atlantic/Azores
new file mode 100644
index 0000000000000000000000000000000000000000..cda1c1d225ae261ae433579e56d94a84ae2acd38
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Azores differ
diff --git a/marketing/share/zoneinfo/Atlantic/Bermuda b/marketing/share/zoneinfo/Atlantic/Bermuda
new file mode 100644
index 0000000000000000000000000000000000000000..abc75ea7ef87f054cdcea06728b99e3540108860
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Bermuda differ
diff --git a/marketing/share/zoneinfo/Atlantic/Canary b/marketing/share/zoneinfo/Atlantic/Canary
new file mode 100644
index 0000000000000000000000000000000000000000..5ab3243a5f01f5056127f160cfe693c33edf0531
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Canary differ
diff --git a/marketing/share/zoneinfo/Atlantic/Cape_Verde b/marketing/share/zoneinfo/Atlantic/Cape_Verde
new file mode 100644
index 0000000000000000000000000000000000000000..8f7de1c0a19a8d3e0e749626c76c8d4dbd3c4de7
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Cape_Verde differ
diff --git a/marketing/share/zoneinfo/Atlantic/Faeroe b/marketing/share/zoneinfo/Atlantic/Faeroe
new file mode 100644
index 0000000000000000000000000000000000000000..9558bf7180acab14d3b3f63c956f5224f680b2a3
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Faeroe differ
diff --git a/marketing/share/zoneinfo/Atlantic/Faroe b/marketing/share/zoneinfo/Atlantic/Faroe
new file mode 100644
index 0000000000000000000000000000000000000000..9558bf7180acab14d3b3f63c956f5224f680b2a3
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Faroe differ
diff --git a/marketing/share/zoneinfo/Atlantic/Jan_Mayen b/marketing/share/zoneinfo/Atlantic/Jan_Mayen
new file mode 100644
index 0000000000000000000000000000000000000000..465546bd396ae5eb75076f13ba9c29b0c926c835
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Jan_Mayen differ
diff --git a/marketing/share/zoneinfo/Atlantic/Madeira b/marketing/share/zoneinfo/Atlantic/Madeira
new file mode 100644
index 0000000000000000000000000000000000000000..21e84571ee1694758dd244ed0702fbae962648e6
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Madeira differ
diff --git a/marketing/share/zoneinfo/Atlantic/Reykjavik b/marketing/share/zoneinfo/Atlantic/Reykjavik
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Reykjavik differ
diff --git a/marketing/share/zoneinfo/Atlantic/South_Georgia b/marketing/share/zoneinfo/Atlantic/South_Georgia
new file mode 100644
index 0000000000000000000000000000000000000000..7fa5f4683538498b93d1e639c14256c1f033c354
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/South_Georgia differ
diff --git a/marketing/share/zoneinfo/Atlantic/St_Helena b/marketing/share/zoneinfo/Atlantic/St_Helena
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/St_Helena differ
diff --git a/marketing/share/zoneinfo/Atlantic/Stanley b/marketing/share/zoneinfo/Atlantic/Stanley
new file mode 100644
index 0000000000000000000000000000000000000000..1a4c8ea86361731f4d7e854ac66d96a5ce6b2dbf
Binary files /dev/null and b/marketing/share/zoneinfo/Atlantic/Stanley differ
diff --git a/marketing/share/zoneinfo/Australia/ACT b/marketing/share/zoneinfo/Australia/ACT
new file mode 100644
index 0000000000000000000000000000000000000000..1975a3a4bd0ed93db1d10a2c562eb5bc3baaa489
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/ACT differ
diff --git a/marketing/share/zoneinfo/Australia/Adelaide b/marketing/share/zoneinfo/Australia/Adelaide
new file mode 100644
index 0000000000000000000000000000000000000000..3bfbbc563cf97dc2548ff8974ab23dcde28e8744
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Adelaide differ
diff --git a/marketing/share/zoneinfo/Australia/Brisbane b/marketing/share/zoneinfo/Australia/Brisbane
new file mode 100644
index 0000000000000000000000000000000000000000..dc9a980a65923b6629d788e4e03b4358ac151c15
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Brisbane differ
diff --git a/marketing/share/zoneinfo/Australia/Broken_Hill b/marketing/share/zoneinfo/Australia/Broken_Hill
new file mode 100644
index 0000000000000000000000000000000000000000..947b50995f4045ee6562cae21120dc8a05687653
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Broken_Hill differ
diff --git a/marketing/share/zoneinfo/Australia/Canberra b/marketing/share/zoneinfo/Australia/Canberra
new file mode 100644
index 0000000000000000000000000000000000000000..1975a3a4bd0ed93db1d10a2c562eb5bc3baaa489
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Canberra differ
diff --git a/marketing/share/zoneinfo/Australia/Currie b/marketing/share/zoneinfo/Australia/Currie
new file mode 100644
index 0000000000000000000000000000000000000000..dc2ef554dc389f4a34146329935e5c3581a0f2f4
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Currie differ
diff --git a/marketing/share/zoneinfo/Australia/Darwin b/marketing/share/zoneinfo/Australia/Darwin
new file mode 100644
index 0000000000000000000000000000000000000000..a6a67300dd5ef87e421c9749702039a6bdbb928f
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Darwin differ
diff --git a/marketing/share/zoneinfo/Australia/Eucla b/marketing/share/zoneinfo/Australia/Eucla
new file mode 100644
index 0000000000000000000000000000000000000000..9080f5cdb1216ef6397e7de6205173caa794c646
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Eucla differ
diff --git a/marketing/share/zoneinfo/Australia/Hobart b/marketing/share/zoneinfo/Australia/Hobart
new file mode 100644
index 0000000000000000000000000000000000000000..dc2ef554dc389f4a34146329935e5c3581a0f2f4
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Hobart differ
diff --git a/marketing/share/zoneinfo/Australia/LHI b/marketing/share/zoneinfo/Australia/LHI
new file mode 100644
index 0000000000000000000000000000000000000000..4d4ec8ceea9a96956864eddff4900fc4fb9ba8f1
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/LHI differ
diff --git a/marketing/share/zoneinfo/Australia/Lindeman b/marketing/share/zoneinfo/Australia/Lindeman
new file mode 100644
index 0000000000000000000000000000000000000000..131d77b54a2087ada0bb3a27d03bf752f84326a7
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Lindeman differ
diff --git a/marketing/share/zoneinfo/Australia/Lord_Howe b/marketing/share/zoneinfo/Australia/Lord_Howe
new file mode 100644
index 0000000000000000000000000000000000000000..4d4ec8ceea9a96956864eddff4900fc4fb9ba8f1
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Lord_Howe differ
diff --git a/marketing/share/zoneinfo/Australia/Melbourne b/marketing/share/zoneinfo/Australia/Melbourne
new file mode 100644
index 0000000000000000000000000000000000000000..d3f195ac2fac23afd46cc16650e0a2454f5a3923
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Melbourne differ
diff --git a/marketing/share/zoneinfo/Australia/NSW b/marketing/share/zoneinfo/Australia/NSW
new file mode 100644
index 0000000000000000000000000000000000000000..1975a3a4bd0ed93db1d10a2c562eb5bc3baaa489
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/NSW differ
diff --git a/marketing/share/zoneinfo/Australia/North b/marketing/share/zoneinfo/Australia/North
new file mode 100644
index 0000000000000000000000000000000000000000..a6a67300dd5ef87e421c9749702039a6bdbb928f
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/North differ
diff --git a/marketing/share/zoneinfo/Australia/Perth b/marketing/share/zoneinfo/Australia/Perth
new file mode 100644
index 0000000000000000000000000000000000000000..4f771828c9b54d9bcaef82639425df4b3559b5e1
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Perth differ
diff --git a/marketing/share/zoneinfo/Australia/Queensland b/marketing/share/zoneinfo/Australia/Queensland
new file mode 100644
index 0000000000000000000000000000000000000000..dc9a980a65923b6629d788e4e03b4358ac151c15
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Queensland differ
diff --git a/marketing/share/zoneinfo/Australia/South b/marketing/share/zoneinfo/Australia/South
new file mode 100644
index 0000000000000000000000000000000000000000..3bfbbc563cf97dc2548ff8974ab23dcde28e8744
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/South differ
diff --git a/marketing/share/zoneinfo/Australia/Sydney b/marketing/share/zoneinfo/Australia/Sydney
new file mode 100644
index 0000000000000000000000000000000000000000..1975a3a4bd0ed93db1d10a2c562eb5bc3baaa489
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Sydney differ
diff --git a/marketing/share/zoneinfo/Australia/Tasmania b/marketing/share/zoneinfo/Australia/Tasmania
new file mode 100644
index 0000000000000000000000000000000000000000..dc2ef554dc389f4a34146329935e5c3581a0f2f4
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Tasmania differ
diff --git a/marketing/share/zoneinfo/Australia/Victoria b/marketing/share/zoneinfo/Australia/Victoria
new file mode 100644
index 0000000000000000000000000000000000000000..d3f195ac2fac23afd46cc16650e0a2454f5a3923
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Victoria differ
diff --git a/marketing/share/zoneinfo/Australia/West b/marketing/share/zoneinfo/Australia/West
new file mode 100644
index 0000000000000000000000000000000000000000..4f771828c9b54d9bcaef82639425df4b3559b5e1
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/West differ
diff --git a/marketing/share/zoneinfo/Australia/Yancowinna b/marketing/share/zoneinfo/Australia/Yancowinna
new file mode 100644
index 0000000000000000000000000000000000000000..947b50995f4045ee6562cae21120dc8a05687653
Binary files /dev/null and b/marketing/share/zoneinfo/Australia/Yancowinna differ
diff --git a/marketing/share/zoneinfo/Brazil/Acre b/marketing/share/zoneinfo/Brazil/Acre
new file mode 100644
index 0000000000000000000000000000000000000000..fb5185ca60283bd56f795e9a956274c0b6e63325
Binary files /dev/null and b/marketing/share/zoneinfo/Brazil/Acre differ
diff --git a/marketing/share/zoneinfo/Brazil/DeNoronha b/marketing/share/zoneinfo/Brazil/DeNoronha
new file mode 100644
index 0000000000000000000000000000000000000000..9e74745ca79137918281337fa270c5fec4bd7da1
Binary files /dev/null and b/marketing/share/zoneinfo/Brazil/DeNoronha differ
diff --git a/marketing/share/zoneinfo/Brazil/East b/marketing/share/zoneinfo/Brazil/East
new file mode 100644
index 0000000000000000000000000000000000000000..a16da2c4d5a980cd944d86c34ea8a2f597e39b71
Binary files /dev/null and b/marketing/share/zoneinfo/Brazil/East differ
diff --git a/marketing/share/zoneinfo/Brazil/West b/marketing/share/zoneinfo/Brazil/West
new file mode 100644
index 0000000000000000000000000000000000000000..59c952ebc65169dce30078a3e1ee371e0da52ae4
Binary files /dev/null and b/marketing/share/zoneinfo/Brazil/West differ
diff --git a/marketing/share/zoneinfo/CET b/marketing/share/zoneinfo/CET
new file mode 100644
index 0000000000000000000000000000000000000000..31973271d2f87f7e9df4e8b0a1481f09a9e5407d
Binary files /dev/null and b/marketing/share/zoneinfo/CET differ
diff --git a/marketing/share/zoneinfo/CST6CDT b/marketing/share/zoneinfo/CST6CDT
new file mode 100644
index 0000000000000000000000000000000000000000..b016880653929aa40dd5ac0e82e4094a9d787cdf
Binary files /dev/null and b/marketing/share/zoneinfo/CST6CDT differ
diff --git a/marketing/share/zoneinfo/Canada/Atlantic b/marketing/share/zoneinfo/Canada/Atlantic
new file mode 100644
index 0000000000000000000000000000000000000000..9fa850a7d4c36dea84149bc0ea2fcd3581d61a8c
Binary files /dev/null and b/marketing/share/zoneinfo/Canada/Atlantic differ
diff --git a/marketing/share/zoneinfo/Canada/Central b/marketing/share/zoneinfo/Canada/Central
new file mode 100644
index 0000000000000000000000000000000000000000..7e646d18e18851bfde743b379e52df4ec5b5a20f
Binary files /dev/null and b/marketing/share/zoneinfo/Canada/Central differ
diff --git a/marketing/share/zoneinfo/Canada/Eastern b/marketing/share/zoneinfo/Canada/Eastern
new file mode 100644
index 0000000000000000000000000000000000000000..668e70d765dc3fb0eda16fb0f1932af607b53412
Binary files /dev/null and b/marketing/share/zoneinfo/Canada/Eastern differ
diff --git a/marketing/share/zoneinfo/Canada/Mountain b/marketing/share/zoneinfo/Canada/Mountain
new file mode 100644
index 0000000000000000000000000000000000000000..645ee9453073acf4cff9f9420b358a8ebbe40f93
Binary files /dev/null and b/marketing/share/zoneinfo/Canada/Mountain differ
diff --git a/marketing/share/zoneinfo/Canada/Newfoundland b/marketing/share/zoneinfo/Canada/Newfoundland
new file mode 100644
index 0000000000000000000000000000000000000000..94d790baaccb72298bb577041cf3c8400339a7da
Binary files /dev/null and b/marketing/share/zoneinfo/Canada/Newfoundland differ
diff --git a/marketing/share/zoneinfo/Canada/Pacific b/marketing/share/zoneinfo/Canada/Pacific
new file mode 100644
index 0000000000000000000000000000000000000000..c998491112ea5e4430b8266498cf7f23e1266bc5
Binary files /dev/null and b/marketing/share/zoneinfo/Canada/Pacific differ
diff --git a/marketing/share/zoneinfo/Canada/Saskatchewan b/marketing/share/zoneinfo/Canada/Saskatchewan
new file mode 100644
index 0000000000000000000000000000000000000000..a3f8217a544ebb0993473bbffaae8e2d723c4ec3
Binary files /dev/null and b/marketing/share/zoneinfo/Canada/Saskatchewan differ
diff --git a/marketing/share/zoneinfo/Canada/Yukon b/marketing/share/zoneinfo/Canada/Yukon
new file mode 100644
index 0000000000000000000000000000000000000000..40baa9aba2a879f7a38a5a0f67e16e7a2d677a5e
Binary files /dev/null and b/marketing/share/zoneinfo/Canada/Yukon differ
diff --git a/marketing/share/zoneinfo/Chile/Continental b/marketing/share/zoneinfo/Chile/Continental
new file mode 100644
index 0000000000000000000000000000000000000000..d3fc9b8343369abf5f14be781397f426c5969608
Binary files /dev/null and b/marketing/share/zoneinfo/Chile/Continental differ
diff --git a/marketing/share/zoneinfo/Chile/EasterIsland b/marketing/share/zoneinfo/Chile/EasterIsland
new file mode 100644
index 0000000000000000000000000000000000000000..54dff005b876339f5c1ff3dc0aeae1519c29b368
Binary files /dev/null and b/marketing/share/zoneinfo/Chile/EasterIsland differ
diff --git a/marketing/share/zoneinfo/Cuba b/marketing/share/zoneinfo/Cuba
new file mode 100644
index 0000000000000000000000000000000000000000..e06629d36841463326ff3350bc2f94d0417c3cdd
Binary files /dev/null and b/marketing/share/zoneinfo/Cuba differ
diff --git a/marketing/share/zoneinfo/EET b/marketing/share/zoneinfo/EET
new file mode 100644
index 0000000000000000000000000000000000000000..231bf9c3b713e3676dbd8f3ced867973c601e104
Binary files /dev/null and b/marketing/share/zoneinfo/EET differ
diff --git a/marketing/share/zoneinfo/EST b/marketing/share/zoneinfo/EST
new file mode 100644
index 0000000000000000000000000000000000000000..9154643f4c9189998392afb8a93e2e2eb9eaecf5
Binary files /dev/null and b/marketing/share/zoneinfo/EST differ
diff --git a/marketing/share/zoneinfo/EST5EDT b/marketing/share/zoneinfo/EST5EDT
new file mode 100644
index 0000000000000000000000000000000000000000..2b6c2eea14df07392729ae9f5712a44ec4f02bae
Binary files /dev/null and b/marketing/share/zoneinfo/EST5EDT differ
diff --git a/marketing/share/zoneinfo/Egypt b/marketing/share/zoneinfo/Egypt
new file mode 100644
index 0000000000000000000000000000000000000000..1e6d48d1ca4e5416913c41e8814dc045c57d5b58
Binary files /dev/null and b/marketing/share/zoneinfo/Egypt differ
diff --git a/marketing/share/zoneinfo/Eire b/marketing/share/zoneinfo/Eire
new file mode 100644
index 0000000000000000000000000000000000000000..17d2b1582df89d5794f20fb028956dd9da154922
Binary files /dev/null and b/marketing/share/zoneinfo/Eire differ
diff --git a/marketing/share/zoneinfo/Etc/GMT b/marketing/share/zoneinfo/Etc/GMT
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+0 b/marketing/share/zoneinfo/Etc/GMT+0
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+0 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+1 b/marketing/share/zoneinfo/Etc/GMT+1
new file mode 100644
index 0000000000000000000000000000000000000000..98d5dcf917c6f1d9bd0018db0dc4dd0590e6a8ca
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+1 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+10 b/marketing/share/zoneinfo/Etc/GMT+10
new file mode 100644
index 0000000000000000000000000000000000000000..ecb287e667868e92d97cdf5fee601e09cded0ff2
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+10 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+11 b/marketing/share/zoneinfo/Etc/GMT+11
new file mode 100644
index 0000000000000000000000000000000000000000..e941412971a4d805e311e8e4e7eb37e10994e4be
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+11 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+12 b/marketing/share/zoneinfo/Etc/GMT+12
new file mode 100644
index 0000000000000000000000000000000000000000..9c95bd0736da8932cd70e1d9590f8a3ab676c620
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+12 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+2 b/marketing/share/zoneinfo/Etc/GMT+2
new file mode 100644
index 0000000000000000000000000000000000000000..6d5ce3db7323d63f73e9e92b6f4d3d6b77632a94
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+2 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+3 b/marketing/share/zoneinfo/Etc/GMT+3
new file mode 100644
index 0000000000000000000000000000000000000000..5ef7be71fd96e4ef66fce3ab675303559dbb22a3
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+3 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+4 b/marketing/share/zoneinfo/Etc/GMT+4
new file mode 100644
index 0000000000000000000000000000000000000000..75f16216f0d39ff98d969cd1f6703473f6fea50f
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+4 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+5 b/marketing/share/zoneinfo/Etc/GMT+5
new file mode 100644
index 0000000000000000000000000000000000000000..589990ae8966d1af67f1e05c21e14149adec2089
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+5 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+6 b/marketing/share/zoneinfo/Etc/GMT+6
new file mode 100644
index 0000000000000000000000000000000000000000..fcb60ca2465a3e0c4febd41ac1a05bbb39fd96ed
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+6 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+7 b/marketing/share/zoneinfo/Etc/GMT+7
new file mode 100644
index 0000000000000000000000000000000000000000..c0427a40eef929dcf25451be77c74af6e9111065
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+7 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+8 b/marketing/share/zoneinfo/Etc/GMT+8
new file mode 100644
index 0000000000000000000000000000000000000000..9bdc2283c07d8dae0bb0147c7a7c648ac6a30405
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+8 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT+9 b/marketing/share/zoneinfo/Etc/GMT+9
new file mode 100644
index 0000000000000000000000000000000000000000..ca7a81f656f206f32586fdd294a2b385bb519b6a
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT+9 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-0 b/marketing/share/zoneinfo/Etc/GMT-0
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-0 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-1 b/marketing/share/zoneinfo/Etc/GMT-1
new file mode 100644
index 0000000000000000000000000000000000000000..cb45601c958da687b3e3d63366aa259a8a1c5376
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-1 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-10 b/marketing/share/zoneinfo/Etc/GMT-10
new file mode 100644
index 0000000000000000000000000000000000000000..11d988e10a3e318a7cba485d995872636d1acaf0
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-10 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-11 b/marketing/share/zoneinfo/Etc/GMT-11
new file mode 100644
index 0000000000000000000000000000000000000000..f4c5d5cc29b5c1687e9728b6b63cd2a5328c9dfb
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-11 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-12 b/marketing/share/zoneinfo/Etc/GMT-12
new file mode 100644
index 0000000000000000000000000000000000000000..cd397b02cdde1d348db020ce46785285feb312ba
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-12 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-13 b/marketing/share/zoneinfo/Etc/GMT-13
new file mode 100644
index 0000000000000000000000000000000000000000..8fad7c6b0bef4b13898a94f4004726837cde975e
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-13 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-14 b/marketing/share/zoneinfo/Etc/GMT-14
new file mode 100644
index 0000000000000000000000000000000000000000..a595e60eeae161b68617bb401d4acc53dbac1846
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-14 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-2 b/marketing/share/zoneinfo/Etc/GMT-2
new file mode 100644
index 0000000000000000000000000000000000000000..97b44a9baecfd5bd30393142c63323160353bf2f
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-2 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-3 b/marketing/share/zoneinfo/Etc/GMT-3
new file mode 100644
index 0000000000000000000000000000000000000000..4eb17ff0057b8843a0b840c6fef4b77accfe43b5
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-3 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-4 b/marketing/share/zoneinfo/Etc/GMT-4
new file mode 100644
index 0000000000000000000000000000000000000000..13aef80cbbcf0c938b8d11d92b0755e146a501d2
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-4 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-5 b/marketing/share/zoneinfo/Etc/GMT-5
new file mode 100644
index 0000000000000000000000000000000000000000..83a28169552f4fd39e9d0322398d787aad303e3c
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-5 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-6 b/marketing/share/zoneinfo/Etc/GMT-6
new file mode 100644
index 0000000000000000000000000000000000000000..79a983e5454a35f134cd4ad736ed912f3deae64f
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-6 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-7 b/marketing/share/zoneinfo/Etc/GMT-7
new file mode 100644
index 0000000000000000000000000000000000000000..e136690e165a933fbad2fdc0aba8d97886714fe0
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-7 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-8 b/marketing/share/zoneinfo/Etc/GMT-8
new file mode 100644
index 0000000000000000000000000000000000000000..bc70fe416fdbe3abb2c636a7bc1485b79e03af13
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-8 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT-9 b/marketing/share/zoneinfo/Etc/GMT-9
new file mode 100644
index 0000000000000000000000000000000000000000..d18cedd524f4cc132106d822fa8bb9bd3779edab
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT-9 differ
diff --git a/marketing/share/zoneinfo/Etc/GMT0 b/marketing/share/zoneinfo/Etc/GMT0
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/GMT0 differ
diff --git a/marketing/share/zoneinfo/Etc/Greenwich b/marketing/share/zoneinfo/Etc/Greenwich
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/Greenwich differ
diff --git a/marketing/share/zoneinfo/Etc/UCT b/marketing/share/zoneinfo/Etc/UCT
new file mode 100644
index 0000000000000000000000000000000000000000..00841a62213e6cccf7f0b7353e5e8ae214185486
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/UCT differ
diff --git a/marketing/share/zoneinfo/Etc/UTC b/marketing/share/zoneinfo/Etc/UTC
new file mode 100644
index 0000000000000000000000000000000000000000..00841a62213e6cccf7f0b7353e5e8ae214185486
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/UTC differ
diff --git a/marketing/share/zoneinfo/Etc/Universal b/marketing/share/zoneinfo/Etc/Universal
new file mode 100644
index 0000000000000000000000000000000000000000..00841a62213e6cccf7f0b7353e5e8ae214185486
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/Universal differ
diff --git a/marketing/share/zoneinfo/Etc/Zulu b/marketing/share/zoneinfo/Etc/Zulu
new file mode 100644
index 0000000000000000000000000000000000000000..00841a62213e6cccf7f0b7353e5e8ae214185486
Binary files /dev/null and b/marketing/share/zoneinfo/Etc/Zulu differ
diff --git a/marketing/share/zoneinfo/Europe/Amsterdam b/marketing/share/zoneinfo/Europe/Amsterdam
new file mode 100644
index 0000000000000000000000000000000000000000..31973271d2f87f7e9df4e8b0a1481f09a9e5407d
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Amsterdam differ
diff --git a/marketing/share/zoneinfo/Europe/Andorra b/marketing/share/zoneinfo/Europe/Andorra
new file mode 100644
index 0000000000000000000000000000000000000000..38685d4219d244f56f665c8afb92eaa6737badb8
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Andorra differ
diff --git a/marketing/share/zoneinfo/Europe/Astrakhan b/marketing/share/zoneinfo/Europe/Astrakhan
new file mode 100644
index 0000000000000000000000000000000000000000..aff8d82d2a2de0857f78217cc9d04a112d1e1a08
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Astrakhan differ
diff --git a/marketing/share/zoneinfo/Europe/Athens b/marketing/share/zoneinfo/Europe/Athens
new file mode 100644
index 0000000000000000000000000000000000000000..231bf9c3b713e3676dbd8f3ced867973c601e104
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Athens differ
diff --git a/marketing/share/zoneinfo/Europe/Belfast b/marketing/share/zoneinfo/Europe/Belfast
new file mode 100644
index 0000000000000000000000000000000000000000..b9e95d92623c6cc4c35b16f7ceba3006f5ce4934
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Belfast differ
diff --git a/marketing/share/zoneinfo/Europe/Belgrade b/marketing/share/zoneinfo/Europe/Belgrade
new file mode 100644
index 0000000000000000000000000000000000000000..a1bf9281ed1bc2c9b82ee64efdca60b4af762ede
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Belgrade differ
diff --git a/marketing/share/zoneinfo/Europe/Berlin b/marketing/share/zoneinfo/Europe/Berlin
new file mode 100644
index 0000000000000000000000000000000000000000..465546bd396ae5eb75076f13ba9c29b0c926c835
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Berlin differ
diff --git a/marketing/share/zoneinfo/Europe/Bratislava b/marketing/share/zoneinfo/Europe/Bratislava
new file mode 100644
index 0000000000000000000000000000000000000000..fb7c145ac4c8ab8f39731e75db8c384b7dc4ee11
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Bratislava differ
diff --git a/marketing/share/zoneinfo/Europe/Brussels b/marketing/share/zoneinfo/Europe/Brussels
new file mode 100644
index 0000000000000000000000000000000000000000..31973271d2f87f7e9df4e8b0a1481f09a9e5407d
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Brussels differ
diff --git a/marketing/share/zoneinfo/Europe/Bucharest b/marketing/share/zoneinfo/Europe/Bucharest
new file mode 100644
index 0000000000000000000000000000000000000000..c4a391e73b97e1342d352c5cc15a0bace202deef
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Bucharest differ
diff --git a/marketing/share/zoneinfo/Europe/Budapest b/marketing/share/zoneinfo/Europe/Budapest
new file mode 100644
index 0000000000000000000000000000000000000000..940be4670a64ece1265dd28523d78a80f9008dd2
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Budapest differ
diff --git a/marketing/share/zoneinfo/Europe/Busingen b/marketing/share/zoneinfo/Europe/Busingen
new file mode 100644
index 0000000000000000000000000000000000000000..388df2969f2dc56738183bd4f0d5755c4533a797
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Busingen differ
diff --git a/marketing/share/zoneinfo/Europe/Chisinau b/marketing/share/zoneinfo/Europe/Chisinau
new file mode 100644
index 0000000000000000000000000000000000000000..9152e68594bb66cc756e0407654a203952fbd4e5
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Chisinau differ
diff --git a/marketing/share/zoneinfo/Europe/Copenhagen b/marketing/share/zoneinfo/Europe/Copenhagen
new file mode 100644
index 0000000000000000000000000000000000000000..465546bd396ae5eb75076f13ba9c29b0c926c835
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Copenhagen differ
diff --git a/marketing/share/zoneinfo/Europe/Dublin b/marketing/share/zoneinfo/Europe/Dublin
new file mode 100644
index 0000000000000000000000000000000000000000..17d2b1582df89d5794f20fb028956dd9da154922
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Dublin differ
diff --git a/marketing/share/zoneinfo/Europe/Gibraltar b/marketing/share/zoneinfo/Europe/Gibraltar
new file mode 100644
index 0000000000000000000000000000000000000000..017bb2e34746c8a11c6955d49cc492c974412801
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Gibraltar differ
diff --git a/marketing/share/zoneinfo/Europe/Guernsey b/marketing/share/zoneinfo/Europe/Guernsey
new file mode 100644
index 0000000000000000000000000000000000000000..b9e95d92623c6cc4c35b16f7ceba3006f5ce4934
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Guernsey differ
diff --git a/marketing/share/zoneinfo/Europe/Helsinki b/marketing/share/zoneinfo/Europe/Helsinki
new file mode 100644
index 0000000000000000000000000000000000000000..ff5e56530570974516d249927952c69da601b664
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Helsinki differ
diff --git a/marketing/share/zoneinfo/Europe/Isle_of_Man b/marketing/share/zoneinfo/Europe/Isle_of_Man
new file mode 100644
index 0000000000000000000000000000000000000000..b9e95d92623c6cc4c35b16f7ceba3006f5ce4934
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Isle_of_Man differ
diff --git a/marketing/share/zoneinfo/Europe/Istanbul b/marketing/share/zoneinfo/Europe/Istanbul
new file mode 100644
index 0000000000000000000000000000000000000000..c89186687300068ac4e8505cc0012a1dbf6a9960
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Istanbul differ
diff --git a/marketing/share/zoneinfo/Europe/Jersey b/marketing/share/zoneinfo/Europe/Jersey
new file mode 100644
index 0000000000000000000000000000000000000000..b9e95d92623c6cc4c35b16f7ceba3006f5ce4934
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Jersey differ
diff --git a/marketing/share/zoneinfo/Europe/Kaliningrad b/marketing/share/zoneinfo/Europe/Kaliningrad
new file mode 100644
index 0000000000000000000000000000000000000000..0ec475647055bd235131c6620aa46da7f43209ac
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Kaliningrad differ
diff --git a/marketing/share/zoneinfo/Europe/Kiev b/marketing/share/zoneinfo/Europe/Kiev
new file mode 100644
index 0000000000000000000000000000000000000000..753a6c86f38586797589233f4528837f5b09151c
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Kiev differ
diff --git a/marketing/share/zoneinfo/Europe/Kirov b/marketing/share/zoneinfo/Europe/Kirov
new file mode 100644
index 0000000000000000000000000000000000000000..bfac56111d9cc81a93cce85205c685880433b96f
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Kirov differ
diff --git a/marketing/share/zoneinfo/Europe/Kyiv b/marketing/share/zoneinfo/Europe/Kyiv
new file mode 100644
index 0000000000000000000000000000000000000000..753a6c86f38586797589233f4528837f5b09151c
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Kyiv differ
diff --git a/marketing/share/zoneinfo/Europe/Lisbon b/marketing/share/zoneinfo/Europe/Lisbon
new file mode 100644
index 0000000000000000000000000000000000000000..7e9aae727b2b660e7f5e383121f445daf033a9c5
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Lisbon differ
diff --git a/marketing/share/zoneinfo/Europe/Ljubljana b/marketing/share/zoneinfo/Europe/Ljubljana
new file mode 100644
index 0000000000000000000000000000000000000000..a1bf9281ed1bc2c9b82ee64efdca60b4af762ede
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Ljubljana differ
diff --git a/marketing/share/zoneinfo/Europe/London b/marketing/share/zoneinfo/Europe/London
new file mode 100644
index 0000000000000000000000000000000000000000..b9e95d92623c6cc4c35b16f7ceba3006f5ce4934
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/London differ
diff --git a/marketing/share/zoneinfo/Europe/Luxembourg b/marketing/share/zoneinfo/Europe/Luxembourg
new file mode 100644
index 0000000000000000000000000000000000000000..31973271d2f87f7e9df4e8b0a1481f09a9e5407d
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Luxembourg differ
diff --git a/marketing/share/zoneinfo/Europe/Madrid b/marketing/share/zoneinfo/Europe/Madrid
new file mode 100644
index 0000000000000000000000000000000000000000..60bdf4d07e6ef544ff18013b272dfb851f1cc27c
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Madrid differ
diff --git a/marketing/share/zoneinfo/Europe/Malta b/marketing/share/zoneinfo/Europe/Malta
new file mode 100644
index 0000000000000000000000000000000000000000..27539c2243ff2c6be1fe890995485be2df39bf77
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Malta differ
diff --git a/marketing/share/zoneinfo/Europe/Mariehamn b/marketing/share/zoneinfo/Europe/Mariehamn
new file mode 100644
index 0000000000000000000000000000000000000000..ff5e56530570974516d249927952c69da601b664
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Mariehamn differ
diff --git a/marketing/share/zoneinfo/Europe/Minsk b/marketing/share/zoneinfo/Europe/Minsk
new file mode 100644
index 0000000000000000000000000000000000000000..30d3a672bf64d0d787ac92bc75d9bc1cc62855c9
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Minsk differ
diff --git a/marketing/share/zoneinfo/Europe/Monaco b/marketing/share/zoneinfo/Europe/Monaco
new file mode 100644
index 0000000000000000000000000000000000000000..00a27264c2cb3e28f2f46e5c267e12d575236a9d
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Monaco differ
diff --git a/marketing/share/zoneinfo/Europe/Moscow b/marketing/share/zoneinfo/Europe/Moscow
new file mode 100644
index 0000000000000000000000000000000000000000..5e6b6de6451b4408fb71ef73950712a0827d49a6
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Moscow differ
diff --git a/marketing/share/zoneinfo/Europe/Nicosia b/marketing/share/zoneinfo/Europe/Nicosia
new file mode 100644
index 0000000000000000000000000000000000000000..390347f442a486e296689c189e3346695bba5105
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Nicosia differ
diff --git a/marketing/share/zoneinfo/Europe/Oslo b/marketing/share/zoneinfo/Europe/Oslo
new file mode 100644
index 0000000000000000000000000000000000000000..465546bd396ae5eb75076f13ba9c29b0c926c835
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Oslo differ
diff --git a/marketing/share/zoneinfo/Europe/Paris b/marketing/share/zoneinfo/Europe/Paris
new file mode 100644
index 0000000000000000000000000000000000000000..00a27264c2cb3e28f2f46e5c267e12d575236a9d
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Paris differ
diff --git a/marketing/share/zoneinfo/Europe/Podgorica b/marketing/share/zoneinfo/Europe/Podgorica
new file mode 100644
index 0000000000000000000000000000000000000000..a1bf9281ed1bc2c9b82ee64efdca60b4af762ede
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Podgorica differ
diff --git a/marketing/share/zoneinfo/Europe/Prague b/marketing/share/zoneinfo/Europe/Prague
new file mode 100644
index 0000000000000000000000000000000000000000..fb7c145ac4c8ab8f39731e75db8c384b7dc4ee11
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Prague differ
diff --git a/marketing/share/zoneinfo/Europe/Riga b/marketing/share/zoneinfo/Europe/Riga
new file mode 100644
index 0000000000000000000000000000000000000000..d99170b6420d4b91ec0c0e4652136f765974e0d8
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Riga differ
diff --git a/marketing/share/zoneinfo/Europe/Rome b/marketing/share/zoneinfo/Europe/Rome
new file mode 100644
index 0000000000000000000000000000000000000000..639ca3be4062496b10a8dee26be3733cf457fbdd
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Rome differ
diff --git a/marketing/share/zoneinfo/Europe/Samara b/marketing/share/zoneinfo/Europe/Samara
new file mode 100644
index 0000000000000000000000000000000000000000..8d0c26e5c85294b799e1f346994b04948d3175fe
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Samara differ
diff --git a/marketing/share/zoneinfo/Europe/San_Marino b/marketing/share/zoneinfo/Europe/San_Marino
new file mode 100644
index 0000000000000000000000000000000000000000..639ca3be4062496b10a8dee26be3733cf457fbdd
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/San_Marino differ
diff --git a/marketing/share/zoneinfo/Europe/Sarajevo b/marketing/share/zoneinfo/Europe/Sarajevo
new file mode 100644
index 0000000000000000000000000000000000000000..a1bf9281ed1bc2c9b82ee64efdca60b4af762ede
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Sarajevo differ
diff --git a/marketing/share/zoneinfo/Europe/Saratov b/marketing/share/zoneinfo/Europe/Saratov
new file mode 100644
index 0000000000000000000000000000000000000000..2684d8f8b89f7807ed4a0fcba89822b24a0166bb
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Saratov differ
diff --git a/marketing/share/zoneinfo/Europe/Simferopol b/marketing/share/zoneinfo/Europe/Simferopol
new file mode 100644
index 0000000000000000000000000000000000000000..298b8326ca7ab3e86b5f508fd06fc744b4a142f6
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Simferopol differ
diff --git a/marketing/share/zoneinfo/Europe/Skopje b/marketing/share/zoneinfo/Europe/Skopje
new file mode 100644
index 0000000000000000000000000000000000000000..a1bf9281ed1bc2c9b82ee64efdca60b4af762ede
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Skopje differ
diff --git a/marketing/share/zoneinfo/Europe/Sofia b/marketing/share/zoneinfo/Europe/Sofia
new file mode 100644
index 0000000000000000000000000000000000000000..89450685cd149950dc6d65d1b4f076d96c3dc9a0
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Sofia differ
diff --git a/marketing/share/zoneinfo/Europe/Stockholm b/marketing/share/zoneinfo/Europe/Stockholm
new file mode 100644
index 0000000000000000000000000000000000000000..465546bd396ae5eb75076f13ba9c29b0c926c835
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Stockholm differ
diff --git a/marketing/share/zoneinfo/Europe/Tallinn b/marketing/share/zoneinfo/Europe/Tallinn
new file mode 100644
index 0000000000000000000000000000000000000000..fbebdc6255b547b1f3a547f0f92cc8148f05f186
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Tallinn differ
diff --git a/marketing/share/zoneinfo/Europe/Tirane b/marketing/share/zoneinfo/Europe/Tirane
new file mode 100644
index 0000000000000000000000000000000000000000..743a7337ffd8c404d1da0d2d078ea1cd8459affe
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Tirane differ
diff --git a/marketing/share/zoneinfo/Europe/Tiraspol b/marketing/share/zoneinfo/Europe/Tiraspol
new file mode 100644
index 0000000000000000000000000000000000000000..9152e68594bb66cc756e0407654a203952fbd4e5
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Tiraspol differ
diff --git a/marketing/share/zoneinfo/Europe/Ulyanovsk b/marketing/share/zoneinfo/Europe/Ulyanovsk
new file mode 100644
index 0000000000000000000000000000000000000000..bb842cb1f5087d422630f76f17c3a5eee6490a6b
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Ulyanovsk differ
diff --git a/marketing/share/zoneinfo/Europe/Uzhgorod b/marketing/share/zoneinfo/Europe/Uzhgorod
new file mode 100644
index 0000000000000000000000000000000000000000..753a6c86f38586797589233f4528837f5b09151c
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Uzhgorod differ
diff --git a/marketing/share/zoneinfo/Europe/Vaduz b/marketing/share/zoneinfo/Europe/Vaduz
new file mode 100644
index 0000000000000000000000000000000000000000..388df2969f2dc56738183bd4f0d5755c4533a797
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Vaduz differ
diff --git a/marketing/share/zoneinfo/Europe/Vatican b/marketing/share/zoneinfo/Europe/Vatican
new file mode 100644
index 0000000000000000000000000000000000000000..639ca3be4062496b10a8dee26be3733cf457fbdd
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Vatican differ
diff --git a/marketing/share/zoneinfo/Europe/Vienna b/marketing/share/zoneinfo/Europe/Vienna
new file mode 100644
index 0000000000000000000000000000000000000000..75339e98d0a72f2792924294d7a9e560dba4648f
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Vienna differ
diff --git a/marketing/share/zoneinfo/Europe/Vilnius b/marketing/share/zoneinfo/Europe/Vilnius
new file mode 100644
index 0000000000000000000000000000000000000000..43c3d7f1089366e1c48297906c2693712ac6d99c
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Vilnius differ
diff --git a/marketing/share/zoneinfo/Europe/Volgograd b/marketing/share/zoneinfo/Europe/Volgograd
new file mode 100644
index 0000000000000000000000000000000000000000..0715d58bc1873c8bae589a08752cbbae562692c7
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Volgograd differ
diff --git a/marketing/share/zoneinfo/Europe/Warsaw b/marketing/share/zoneinfo/Europe/Warsaw
new file mode 100644
index 0000000000000000000000000000000000000000..efe1a40f2a8ffd499d22cd83e6b5df6c6c1e8e5c
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Warsaw differ
diff --git a/marketing/share/zoneinfo/Europe/Zagreb b/marketing/share/zoneinfo/Europe/Zagreb
new file mode 100644
index 0000000000000000000000000000000000000000..a1bf9281ed1bc2c9b82ee64efdca60b4af762ede
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Zagreb differ
diff --git a/marketing/share/zoneinfo/Europe/Zaporozhye b/marketing/share/zoneinfo/Europe/Zaporozhye
new file mode 100644
index 0000000000000000000000000000000000000000..753a6c86f38586797589233f4528837f5b09151c
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Zaporozhye differ
diff --git a/marketing/share/zoneinfo/Europe/Zurich b/marketing/share/zoneinfo/Europe/Zurich
new file mode 100644
index 0000000000000000000000000000000000000000..388df2969f2dc56738183bd4f0d5755c4533a797
Binary files /dev/null and b/marketing/share/zoneinfo/Europe/Zurich differ
diff --git a/marketing/share/zoneinfo/Factory b/marketing/share/zoneinfo/Factory
new file mode 100644
index 0000000000000000000000000000000000000000..b4dd7735ed5b945e3403f2dd7cd57712dc9184d3
Binary files /dev/null and b/marketing/share/zoneinfo/Factory differ
diff --git a/marketing/share/zoneinfo/GB b/marketing/share/zoneinfo/GB
new file mode 100644
index 0000000000000000000000000000000000000000..b9e95d92623c6cc4c35b16f7ceba3006f5ce4934
Binary files /dev/null and b/marketing/share/zoneinfo/GB differ
diff --git a/marketing/share/zoneinfo/GB-Eire b/marketing/share/zoneinfo/GB-Eire
new file mode 100644
index 0000000000000000000000000000000000000000..b9e95d92623c6cc4c35b16f7ceba3006f5ce4934
Binary files /dev/null and b/marketing/share/zoneinfo/GB-Eire differ
diff --git a/marketing/share/zoneinfo/GMT b/marketing/share/zoneinfo/GMT
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/GMT differ
diff --git a/marketing/share/zoneinfo/GMT+0 b/marketing/share/zoneinfo/GMT+0
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/GMT+0 differ
diff --git a/marketing/share/zoneinfo/GMT-0 b/marketing/share/zoneinfo/GMT-0
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/GMT-0 differ
diff --git a/marketing/share/zoneinfo/GMT0 b/marketing/share/zoneinfo/GMT0
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/GMT0 differ
diff --git a/marketing/share/zoneinfo/Greenwich b/marketing/share/zoneinfo/Greenwich
new file mode 100644
index 0000000000000000000000000000000000000000..157573b1d340e0f57a0dd4d9698bd3798cbf7136
Binary files /dev/null and b/marketing/share/zoneinfo/Greenwich differ
diff --git a/marketing/share/zoneinfo/HST b/marketing/share/zoneinfo/HST
new file mode 100644
index 0000000000000000000000000000000000000000..40e3d492e6c22c30041c31f159d4fe0ee9451c03
Binary files /dev/null and b/marketing/share/zoneinfo/HST differ
diff --git a/marketing/share/zoneinfo/Hongkong b/marketing/share/zoneinfo/Hongkong
new file mode 100644
index 0000000000000000000000000000000000000000..c80e364801be87687625f72e8e2c3dbd0f7ae4bc
Binary files /dev/null and b/marketing/share/zoneinfo/Hongkong differ
diff --git a/marketing/share/zoneinfo/Iceland b/marketing/share/zoneinfo/Iceland
new file mode 100644
index 0000000000000000000000000000000000000000..8906e88c819d9ad3b794eb6356a240a74a95ffae
Binary files /dev/null and b/marketing/share/zoneinfo/Iceland differ
diff --git a/marketing/share/zoneinfo/Indian/Antananarivo b/marketing/share/zoneinfo/Indian/Antananarivo
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Antananarivo differ
diff --git a/marketing/share/zoneinfo/Indian/Chagos b/marketing/share/zoneinfo/Indian/Chagos
new file mode 100644
index 0000000000000000000000000000000000000000..8b8ce226b6b7f67229577b837775e7d448348bde
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Chagos differ
diff --git a/marketing/share/zoneinfo/Indian/Christmas b/marketing/share/zoneinfo/Indian/Christmas
new file mode 100644
index 0000000000000000000000000000000000000000..ed687d2985c208171adcaa3401496b05325edca4
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Christmas differ
diff --git a/marketing/share/zoneinfo/Indian/Cocos b/marketing/share/zoneinfo/Indian/Cocos
new file mode 100644
index 0000000000000000000000000000000000000000..14b2ad09ead50a62d5e2b426396c51f9beb293be
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Cocos differ
diff --git a/marketing/share/zoneinfo/Indian/Comoro b/marketing/share/zoneinfo/Indian/Comoro
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Comoro differ
diff --git a/marketing/share/zoneinfo/Indian/Kerguelen b/marketing/share/zoneinfo/Indian/Kerguelen
new file mode 100644
index 0000000000000000000000000000000000000000..58a82e4eb701ecb0413f908c57080646be392bba
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Kerguelen differ
diff --git a/marketing/share/zoneinfo/Indian/Mahe b/marketing/share/zoneinfo/Indian/Mahe
new file mode 100644
index 0000000000000000000000000000000000000000..58d75bc26eec90272e97696f40483eb56c2b8b45
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Mahe differ
diff --git a/marketing/share/zoneinfo/Indian/Maldives b/marketing/share/zoneinfo/Indian/Maldives
new file mode 100644
index 0000000000000000000000000000000000000000..58a82e4eb701ecb0413f908c57080646be392bba
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Maldives differ
diff --git a/marketing/share/zoneinfo/Indian/Mauritius b/marketing/share/zoneinfo/Indian/Mauritius
new file mode 100644
index 0000000000000000000000000000000000000000..7c1113488200c4d45ddb533bbebd899e2073f750
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Mauritius differ
diff --git a/marketing/share/zoneinfo/Indian/Mayotte b/marketing/share/zoneinfo/Indian/Mayotte
new file mode 100644
index 0000000000000000000000000000000000000000..5f4ebcb7f9789c4ecda13ac66c2e768851113004
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Mayotte differ
diff --git a/marketing/share/zoneinfo/Indian/Reunion b/marketing/share/zoneinfo/Indian/Reunion
new file mode 100644
index 0000000000000000000000000000000000000000..58d75bc26eec90272e97696f40483eb56c2b8b45
Binary files /dev/null and b/marketing/share/zoneinfo/Indian/Reunion differ
diff --git a/marketing/share/zoneinfo/Iran b/marketing/share/zoneinfo/Iran
new file mode 100644
index 0000000000000000000000000000000000000000..824acb0426faaf659a7f209dda6e1ffd0f3ce2ec
Binary files /dev/null and b/marketing/share/zoneinfo/Iran differ
diff --git a/marketing/share/zoneinfo/Israel b/marketing/share/zoneinfo/Israel
new file mode 100644
index 0000000000000000000000000000000000000000..4c49bbf52440631eca750cacb7d79f259eeb8bd2
Binary files /dev/null and b/marketing/share/zoneinfo/Israel differ
diff --git a/marketing/share/zoneinfo/Jamaica b/marketing/share/zoneinfo/Jamaica
new file mode 100644
index 0000000000000000000000000000000000000000..be6b1b6f1e77a8f13a7400bcfc10c63a7ee1d55d
Binary files /dev/null and b/marketing/share/zoneinfo/Jamaica differ
diff --git a/marketing/share/zoneinfo/Japan b/marketing/share/zoneinfo/Japan
new file mode 100644
index 0000000000000000000000000000000000000000..1aa066ce38fce7bd0a680f51d6f075718d153a77
Binary files /dev/null and b/marketing/share/zoneinfo/Japan differ
diff --git a/marketing/share/zoneinfo/Kwajalein b/marketing/share/zoneinfo/Kwajalein
new file mode 100644
index 0000000000000000000000000000000000000000..9416d522d0a3e19ab6b81317f5b94961c55e91fc
Binary files /dev/null and b/marketing/share/zoneinfo/Kwajalein differ
diff --git a/marketing/share/zoneinfo/Libya b/marketing/share/zoneinfo/Libya
new file mode 100644
index 0000000000000000000000000000000000000000..e0c89971aabea2c87842a9276b043d0fd946e34e
Binary files /dev/null and b/marketing/share/zoneinfo/Libya differ
diff --git a/marketing/share/zoneinfo/MET b/marketing/share/zoneinfo/MET
new file mode 100644
index 0000000000000000000000000000000000000000..31973271d2f87f7e9df4e8b0a1481f09a9e5407d
Binary files /dev/null and b/marketing/share/zoneinfo/MET differ
diff --git a/marketing/share/zoneinfo/MST b/marketing/share/zoneinfo/MST
new file mode 100644
index 0000000000000000000000000000000000000000..c2bd2f949b248b835c98216b4dc66f9f6eb0265e
Binary files /dev/null and b/marketing/share/zoneinfo/MST differ
diff --git a/marketing/share/zoneinfo/MST7MDT b/marketing/share/zoneinfo/MST7MDT
new file mode 100644
index 0000000000000000000000000000000000000000..09e54e5c7c5bb2384e37626d4b985cfad29ed29b
Binary files /dev/null and b/marketing/share/zoneinfo/MST7MDT differ
diff --git a/marketing/share/zoneinfo/Mexico/BajaNorte b/marketing/share/zoneinfo/Mexico/BajaNorte
new file mode 100644
index 0000000000000000000000000000000000000000..18d0d14afc1cdf37c8f3607181e3f72211da99e9
Binary files /dev/null and b/marketing/share/zoneinfo/Mexico/BajaNorte differ
diff --git a/marketing/share/zoneinfo/Mexico/BajaSur b/marketing/share/zoneinfo/Mexico/BajaSur
new file mode 100644
index 0000000000000000000000000000000000000000..5aa6039ea4cb36077f048782b54c6275c25e86b3
Binary files /dev/null and b/marketing/share/zoneinfo/Mexico/BajaSur differ
diff --git a/marketing/share/zoneinfo/Mexico/General b/marketing/share/zoneinfo/Mexico/General
new file mode 100644
index 0000000000000000000000000000000000000000..18112346129a885b5d5fa27109682b63784f72c0
Binary files /dev/null and b/marketing/share/zoneinfo/Mexico/General differ
diff --git a/marketing/share/zoneinfo/NZ b/marketing/share/zoneinfo/NZ
new file mode 100644
index 0000000000000000000000000000000000000000..afb3929318475d4f0ea9d6c9e94d0f5f81d8b82e
Binary files /dev/null and b/marketing/share/zoneinfo/NZ differ
diff --git a/marketing/share/zoneinfo/NZ-CHAT b/marketing/share/zoneinfo/NZ-CHAT
new file mode 100644
index 0000000000000000000000000000000000000000..f06065ebd18315683f60cf87839d477a1d699f01
Binary files /dev/null and b/marketing/share/zoneinfo/NZ-CHAT differ
diff --git a/marketing/share/zoneinfo/Navajo b/marketing/share/zoneinfo/Navajo
new file mode 100644
index 0000000000000000000000000000000000000000..09e54e5c7c5bb2384e37626d4b985cfad29ed29b
Binary files /dev/null and b/marketing/share/zoneinfo/Navajo differ
diff --git a/marketing/share/zoneinfo/PRC b/marketing/share/zoneinfo/PRC
new file mode 100644
index 0000000000000000000000000000000000000000..d6b66984a2f36ae36b35e174756707aa7286c292
Binary files /dev/null and b/marketing/share/zoneinfo/PRC differ
diff --git a/marketing/share/zoneinfo/PST8PDT b/marketing/share/zoneinfo/PST8PDT
new file mode 100644
index 0000000000000000000000000000000000000000..aaf07787ad92b65eadae63b64bba290f9f961507
Binary files /dev/null and b/marketing/share/zoneinfo/PST8PDT differ
diff --git a/marketing/share/zoneinfo/Pacific/Apia b/marketing/share/zoneinfo/Pacific/Apia
new file mode 100644
index 0000000000000000000000000000000000000000..a6b835aab4c5e2e2a31bda0afdc8646b57d19a87
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Apia differ
diff --git a/marketing/share/zoneinfo/Pacific/Auckland b/marketing/share/zoneinfo/Pacific/Auckland
new file mode 100644
index 0000000000000000000000000000000000000000..afb3929318475d4f0ea9d6c9e94d0f5f81d8b82e
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Auckland differ
diff --git a/marketing/share/zoneinfo/Pacific/Bougainville b/marketing/share/zoneinfo/Pacific/Bougainville
new file mode 100644
index 0000000000000000000000000000000000000000..7c667093c50d33ce9161662a732fcf6c5092a38b
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Bougainville differ
diff --git a/marketing/share/zoneinfo/Pacific/Chatham b/marketing/share/zoneinfo/Pacific/Chatham
new file mode 100644
index 0000000000000000000000000000000000000000..f06065ebd18315683f60cf87839d477a1d699f01
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Chatham differ
diff --git a/marketing/share/zoneinfo/Pacific/Chuuk b/marketing/share/zoneinfo/Pacific/Chuuk
new file mode 100644
index 0000000000000000000000000000000000000000..5d8fc3a1b253d1df3a0184013469c6e46f6f6f75
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Chuuk differ
diff --git a/marketing/share/zoneinfo/Pacific/Easter b/marketing/share/zoneinfo/Pacific/Easter
new file mode 100644
index 0000000000000000000000000000000000000000..54dff005b876339f5c1ff3dc0aeae1519c29b368
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Easter differ
diff --git a/marketing/share/zoneinfo/Pacific/Efate b/marketing/share/zoneinfo/Pacific/Efate
new file mode 100644
index 0000000000000000000000000000000000000000..bf7471dd3fc26b7fba883acf0e0bf0a69687b31e
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Efate differ
diff --git a/marketing/share/zoneinfo/Pacific/Enderbury b/marketing/share/zoneinfo/Pacific/Enderbury
new file mode 100644
index 0000000000000000000000000000000000000000..2b6a06088ef603f03fb482b628347ff72970fe3d
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Enderbury differ
diff --git a/marketing/share/zoneinfo/Pacific/Fakaofo b/marketing/share/zoneinfo/Pacific/Fakaofo
new file mode 100644
index 0000000000000000000000000000000000000000..b7b30213e154012a5275c1384b41dbff29860644
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Fakaofo differ
diff --git a/marketing/share/zoneinfo/Pacific/Fiji b/marketing/share/zoneinfo/Pacific/Fiji
new file mode 100644
index 0000000000000000000000000000000000000000..610b850b1dec4966d570eb36f9a8b35fd6aacd68
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Fiji differ
diff --git a/marketing/share/zoneinfo/Pacific/Funafuti b/marketing/share/zoneinfo/Pacific/Funafuti
new file mode 100644
index 0000000000000000000000000000000000000000..6bc216823e007c8dbdd6a5e8402b2e0cc5eaf3fc
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Funafuti differ
diff --git a/marketing/share/zoneinfo/Pacific/Galapagos b/marketing/share/zoneinfo/Pacific/Galapagos
new file mode 100644
index 0000000000000000000000000000000000000000..a9403eca467d3b2ccf85b76bf2d94678a2ce3030
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Galapagos differ
diff --git a/marketing/share/zoneinfo/Pacific/Gambier b/marketing/share/zoneinfo/Pacific/Gambier
new file mode 100644
index 0000000000000000000000000000000000000000..ddfc34ffc0971e01ec4f13b78ddfa40033853cd1
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Gambier differ
diff --git a/marketing/share/zoneinfo/Pacific/Guadalcanal b/marketing/share/zoneinfo/Pacific/Guadalcanal
new file mode 100644
index 0000000000000000000000000000000000000000..720c679017404f9b9ecec0687c09a879abf6d256
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Guadalcanal differ
diff --git a/marketing/share/zoneinfo/Pacific/Guam b/marketing/share/zoneinfo/Pacific/Guam
new file mode 100644
index 0000000000000000000000000000000000000000..bf9a2d955fc23bb6c2043472e8292d4adc20d4ed
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Guam differ
diff --git a/marketing/share/zoneinfo/Pacific/Honolulu b/marketing/share/zoneinfo/Pacific/Honolulu
new file mode 100644
index 0000000000000000000000000000000000000000..40e3d492e6c22c30041c31f159d4fe0ee9451c03
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Honolulu differ
diff --git a/marketing/share/zoneinfo/Pacific/Johnston b/marketing/share/zoneinfo/Pacific/Johnston
new file mode 100644
index 0000000000000000000000000000000000000000..40e3d492e6c22c30041c31f159d4fe0ee9451c03
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Johnston differ
diff --git a/marketing/share/zoneinfo/Pacific/Kanton b/marketing/share/zoneinfo/Pacific/Kanton
new file mode 100644
index 0000000000000000000000000000000000000000..2b6a06088ef603f03fb482b628347ff72970fe3d
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Kanton differ
diff --git a/marketing/share/zoneinfo/Pacific/Kiritimati b/marketing/share/zoneinfo/Pacific/Kiritimati
new file mode 100644
index 0000000000000000000000000000000000000000..2f676d3bf5c8599994bcabd402ca30efa4cde5dd
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Kiritimati differ
diff --git a/marketing/share/zoneinfo/Pacific/Kosrae b/marketing/share/zoneinfo/Pacific/Kosrae
new file mode 100644
index 0000000000000000000000000000000000000000..f5d58242c8198bfd7139883e1299b0706704bd32
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Kosrae differ
diff --git a/marketing/share/zoneinfo/Pacific/Kwajalein b/marketing/share/zoneinfo/Pacific/Kwajalein
new file mode 100644
index 0000000000000000000000000000000000000000..9416d522d0a3e19ab6b81317f5b94961c55e91fc
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Kwajalein differ
diff --git a/marketing/share/zoneinfo/Pacific/Majuro b/marketing/share/zoneinfo/Pacific/Majuro
new file mode 100644
index 0000000000000000000000000000000000000000..6bc216823e007c8dbdd6a5e8402b2e0cc5eaf3fc
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Majuro differ
diff --git a/marketing/share/zoneinfo/Pacific/Marquesas b/marketing/share/zoneinfo/Pacific/Marquesas
new file mode 100644
index 0000000000000000000000000000000000000000..6ea24b72cd9552c973510d1c17ace66fd35e1cc5
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Marquesas differ
diff --git a/marketing/share/zoneinfo/Pacific/Midway b/marketing/share/zoneinfo/Pacific/Midway
new file mode 100644
index 0000000000000000000000000000000000000000..001289ceecff85fe0d0f376a6bc394329445f13f
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Midway differ
diff --git a/marketing/share/zoneinfo/Pacific/Nauru b/marketing/share/zoneinfo/Pacific/Nauru
new file mode 100644
index 0000000000000000000000000000000000000000..ae13aac7792a04fe97b0a746f546e52d32f484c5
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Nauru differ
diff --git a/marketing/share/zoneinfo/Pacific/Niue b/marketing/share/zoneinfo/Pacific/Niue
new file mode 100644
index 0000000000000000000000000000000000000000..be874e2472c2a79ed0d4de3011abd8831812911f
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Niue differ
diff --git a/marketing/share/zoneinfo/Pacific/Norfolk b/marketing/share/zoneinfo/Pacific/Norfolk
new file mode 100644
index 0000000000000000000000000000000000000000..0c0bdbda2a72022180bde561f6693268e27beb6b
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Norfolk differ
diff --git a/marketing/share/zoneinfo/Pacific/Noumea b/marketing/share/zoneinfo/Pacific/Noumea
new file mode 100644
index 0000000000000000000000000000000000000000..824f814160ee4a95cc6a6d5553b3c1aacc907895
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Noumea differ
diff --git a/marketing/share/zoneinfo/Pacific/Pago_Pago b/marketing/share/zoneinfo/Pacific/Pago_Pago
new file mode 100644
index 0000000000000000000000000000000000000000..001289ceecff85fe0d0f376a6bc394329445f13f
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Pago_Pago differ
diff --git a/marketing/share/zoneinfo/Pacific/Palau b/marketing/share/zoneinfo/Pacific/Palau
new file mode 100644
index 0000000000000000000000000000000000000000..bc8eb7a55b8a20a8c800507b620d0afef1d477a4
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Palau differ
diff --git a/marketing/share/zoneinfo/Pacific/Pitcairn b/marketing/share/zoneinfo/Pacific/Pitcairn
new file mode 100644
index 0000000000000000000000000000000000000000..8a4ba4d30a6b7da8399f20a8b98c91169e04ae40
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Pitcairn differ
diff --git a/marketing/share/zoneinfo/Pacific/Pohnpei b/marketing/share/zoneinfo/Pacific/Pohnpei
new file mode 100644
index 0000000000000000000000000000000000000000..720c679017404f9b9ecec0687c09a879abf6d256
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Pohnpei differ
diff --git a/marketing/share/zoneinfo/Pacific/Ponape b/marketing/share/zoneinfo/Pacific/Ponape
new file mode 100644
index 0000000000000000000000000000000000000000..720c679017404f9b9ecec0687c09a879abf6d256
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Ponape differ
diff --git a/marketing/share/zoneinfo/Pacific/Port_Moresby b/marketing/share/zoneinfo/Pacific/Port_Moresby
new file mode 100644
index 0000000000000000000000000000000000000000..5d8fc3a1b253d1df3a0184013469c6e46f6f6f75
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Port_Moresby differ
diff --git a/marketing/share/zoneinfo/Pacific/Rarotonga b/marketing/share/zoneinfo/Pacific/Rarotonga
new file mode 100644
index 0000000000000000000000000000000000000000..7220bda0adb9f04d704cb893a5d1ee8bd9173b82
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Rarotonga differ
diff --git a/marketing/share/zoneinfo/Pacific/Saipan b/marketing/share/zoneinfo/Pacific/Saipan
new file mode 100644
index 0000000000000000000000000000000000000000..bf9a2d955fc23bb6c2043472e8292d4adc20d4ed
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Saipan differ
diff --git a/marketing/share/zoneinfo/Pacific/Samoa b/marketing/share/zoneinfo/Pacific/Samoa
new file mode 100644
index 0000000000000000000000000000000000000000..001289ceecff85fe0d0f376a6bc394329445f13f
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Samoa differ
diff --git a/marketing/share/zoneinfo/Pacific/Tahiti b/marketing/share/zoneinfo/Pacific/Tahiti
new file mode 100644
index 0000000000000000000000000000000000000000..50a064fa0166a0dc22f89cdadf957a545d3f6544
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Tahiti differ
diff --git a/marketing/share/zoneinfo/Pacific/Tarawa b/marketing/share/zoneinfo/Pacific/Tarawa
new file mode 100644
index 0000000000000000000000000000000000000000..6bc216823e007c8dbdd6a5e8402b2e0cc5eaf3fc
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Tarawa differ
diff --git a/marketing/share/zoneinfo/Pacific/Tongatapu b/marketing/share/zoneinfo/Pacific/Tongatapu
new file mode 100644
index 0000000000000000000000000000000000000000..f28c8401845f84a68a46d45ec2f5b1383a0274b8
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Tongatapu differ
diff --git a/marketing/share/zoneinfo/Pacific/Truk b/marketing/share/zoneinfo/Pacific/Truk
new file mode 100644
index 0000000000000000000000000000000000000000..5d8fc3a1b253d1df3a0184013469c6e46f6f6f75
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Truk differ
diff --git a/marketing/share/zoneinfo/Pacific/Wake b/marketing/share/zoneinfo/Pacific/Wake
new file mode 100644
index 0000000000000000000000000000000000000000..6bc216823e007c8dbdd6a5e8402b2e0cc5eaf3fc
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Wake differ
diff --git a/marketing/share/zoneinfo/Pacific/Wallis b/marketing/share/zoneinfo/Pacific/Wallis
new file mode 100644
index 0000000000000000000000000000000000000000..6bc216823e007c8dbdd6a5e8402b2e0cc5eaf3fc
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Wallis differ
diff --git a/marketing/share/zoneinfo/Pacific/Yap b/marketing/share/zoneinfo/Pacific/Yap
new file mode 100644
index 0000000000000000000000000000000000000000..5d8fc3a1b253d1df3a0184013469c6e46f6f6f75
Binary files /dev/null and b/marketing/share/zoneinfo/Pacific/Yap differ
diff --git a/marketing/share/zoneinfo/Poland b/marketing/share/zoneinfo/Poland
new file mode 100644
index 0000000000000000000000000000000000000000..efe1a40f2a8ffd499d22cd83e6b5df6c6c1e8e5c
Binary files /dev/null and b/marketing/share/zoneinfo/Poland differ
diff --git a/marketing/share/zoneinfo/Portugal b/marketing/share/zoneinfo/Portugal
new file mode 100644
index 0000000000000000000000000000000000000000..7e9aae727b2b660e7f5e383121f445daf033a9c5
Binary files /dev/null and b/marketing/share/zoneinfo/Portugal differ
diff --git a/marketing/share/zoneinfo/ROC b/marketing/share/zoneinfo/ROC
new file mode 100644
index 0000000000000000000000000000000000000000..35d89d036d07c3f28dec64092ab1b533c21ae2bc
Binary files /dev/null and b/marketing/share/zoneinfo/ROC differ
diff --git a/marketing/share/zoneinfo/ROK b/marketing/share/zoneinfo/ROK
new file mode 100644
index 0000000000000000000000000000000000000000..1755147fab44e07b7527ce1eaf3ae991473fb222
Binary files /dev/null and b/marketing/share/zoneinfo/ROK differ
diff --git a/marketing/share/zoneinfo/Singapore b/marketing/share/zoneinfo/Singapore
new file mode 100644
index 0000000000000000000000000000000000000000..dbbdea3c8149004cfd525a0fc26e5da72b20e8a1
Binary files /dev/null and b/marketing/share/zoneinfo/Singapore differ
diff --git a/marketing/share/zoneinfo/Turkey b/marketing/share/zoneinfo/Turkey
new file mode 100644
index 0000000000000000000000000000000000000000..c89186687300068ac4e8505cc0012a1dbf6a9960
Binary files /dev/null and b/marketing/share/zoneinfo/Turkey differ
diff --git a/marketing/share/zoneinfo/UCT b/marketing/share/zoneinfo/UCT
new file mode 100644
index 0000000000000000000000000000000000000000..00841a62213e6cccf7f0b7353e5e8ae214185486
Binary files /dev/null and b/marketing/share/zoneinfo/UCT differ
diff --git a/marketing/share/zoneinfo/US/Alaska b/marketing/share/zoneinfo/US/Alaska
new file mode 100644
index 0000000000000000000000000000000000000000..cdf0572be31d3052a98494e3d01802b83737f23c
Binary files /dev/null and b/marketing/share/zoneinfo/US/Alaska differ
diff --git a/marketing/share/zoneinfo/US/Aleutian b/marketing/share/zoneinfo/US/Aleutian
new file mode 100644
index 0000000000000000000000000000000000000000..b1497bda631efdcb6635ffb6b0ee6f7da9e2a280
Binary files /dev/null and b/marketing/share/zoneinfo/US/Aleutian differ
diff --git a/marketing/share/zoneinfo/US/Arizona b/marketing/share/zoneinfo/US/Arizona
new file mode 100644
index 0000000000000000000000000000000000000000..c2bd2f949b248b835c98216b4dc66f9f6eb0265e
Binary files /dev/null and b/marketing/share/zoneinfo/US/Arizona differ
diff --git a/marketing/share/zoneinfo/US/Central b/marketing/share/zoneinfo/US/Central
new file mode 100644
index 0000000000000000000000000000000000000000..b016880653929aa40dd5ac0e82e4094a9d787cdf
Binary files /dev/null and b/marketing/share/zoneinfo/US/Central differ
diff --git a/marketing/share/zoneinfo/US/East-Indiana b/marketing/share/zoneinfo/US/East-Indiana
new file mode 100644
index 0000000000000000000000000000000000000000..6b08d15bdaba6cf94dcb2681887154f4d265d8ba
Binary files /dev/null and b/marketing/share/zoneinfo/US/East-Indiana differ
diff --git a/marketing/share/zoneinfo/US/Eastern b/marketing/share/zoneinfo/US/Eastern
new file mode 100644
index 0000000000000000000000000000000000000000..2b6c2eea14df07392729ae9f5712a44ec4f02bae
Binary files /dev/null and b/marketing/share/zoneinfo/US/Eastern differ
diff --git a/marketing/share/zoneinfo/US/Hawaii b/marketing/share/zoneinfo/US/Hawaii
new file mode 100644
index 0000000000000000000000000000000000000000..40e3d492e6c22c30041c31f159d4fe0ee9451c03
Binary files /dev/null and b/marketing/share/zoneinfo/US/Hawaii differ
diff --git a/marketing/share/zoneinfo/US/Indiana-Starke b/marketing/share/zoneinfo/US/Indiana-Starke
new file mode 100644
index 0000000000000000000000000000000000000000..b187d5f8c75685af67913e9360b50ecad19fe6ad
Binary files /dev/null and b/marketing/share/zoneinfo/US/Indiana-Starke differ
diff --git a/marketing/share/zoneinfo/US/Michigan b/marketing/share/zoneinfo/US/Michigan
new file mode 100644
index 0000000000000000000000000000000000000000..6eb3ac46ec56985b52488ae6a8d80247c2adcd4a
Binary files /dev/null and b/marketing/share/zoneinfo/US/Michigan differ
diff --git a/marketing/share/zoneinfo/US/Mountain b/marketing/share/zoneinfo/US/Mountain
new file mode 100644
index 0000000000000000000000000000000000000000..09e54e5c7c5bb2384e37626d4b985cfad29ed29b
Binary files /dev/null and b/marketing/share/zoneinfo/US/Mountain differ
diff --git a/marketing/share/zoneinfo/US/Pacific b/marketing/share/zoneinfo/US/Pacific
new file mode 100644
index 0000000000000000000000000000000000000000..aaf07787ad92b65eadae63b64bba290f9f961507
Binary files /dev/null and b/marketing/share/zoneinfo/US/Pacific differ
diff --git a/marketing/share/zoneinfo/US/Samoa b/marketing/share/zoneinfo/US/Samoa
new file mode 100644
index 0000000000000000000000000000000000000000..001289ceecff85fe0d0f376a6bc394329445f13f
Binary files /dev/null and b/marketing/share/zoneinfo/US/Samoa differ
diff --git a/marketing/share/zoneinfo/UTC b/marketing/share/zoneinfo/UTC
new file mode 100644
index 0000000000000000000000000000000000000000..00841a62213e6cccf7f0b7353e5e8ae214185486
Binary files /dev/null and b/marketing/share/zoneinfo/UTC differ
diff --git a/marketing/share/zoneinfo/Universal b/marketing/share/zoneinfo/Universal
new file mode 100644
index 0000000000000000000000000000000000000000..00841a62213e6cccf7f0b7353e5e8ae214185486
Binary files /dev/null and b/marketing/share/zoneinfo/Universal differ
diff --git a/marketing/share/zoneinfo/W-SU b/marketing/share/zoneinfo/W-SU
new file mode 100644
index 0000000000000000000000000000000000000000..5e6b6de6451b4408fb71ef73950712a0827d49a6
Binary files /dev/null and b/marketing/share/zoneinfo/W-SU differ
diff --git a/marketing/share/zoneinfo/WET b/marketing/share/zoneinfo/WET
new file mode 100644
index 0000000000000000000000000000000000000000..7e9aae727b2b660e7f5e383121f445daf033a9c5
Binary files /dev/null and b/marketing/share/zoneinfo/WET differ
diff --git a/marketing/share/zoneinfo/Zulu b/marketing/share/zoneinfo/Zulu
new file mode 100644
index 0000000000000000000000000000000000000000..00841a62213e6cccf7f0b7353e5e8ae214185486
Binary files /dev/null and b/marketing/share/zoneinfo/Zulu differ
diff --git a/marketing/share/zoneinfo/build/etc/localtime b/marketing/share/zoneinfo/build/etc/localtime
new file mode 100644
index 0000000000000000000000000000000000000000..b4dd7735ed5b945e3403f2dd7cd57712dc9184d3
Binary files /dev/null and b/marketing/share/zoneinfo/build/etc/localtime differ
diff --git a/marketing/share/zoneinfo/iso3166.tab b/marketing/share/zoneinfo/iso3166.tab
new file mode 100644
index 0000000000000000000000000000000000000000..402c015ec6b1071499155f7d28739db68be7763f
--- /dev/null
+++ b/marketing/share/zoneinfo/iso3166.tab
@@ -0,0 +1,279 @@
+# ISO 3166 alpha-2 country codes
+#
+# This file is in the public domain, so clarified as of
+# 2009-05-17 by Arthur David Olson.
+#
+# From Paul Eggert (2023-09-06):
+# This file contains a table of two-letter country codes.  Columns are
+# separated by a single tab.  Lines beginning with '#' are comments.
+# All text uses UTF-8 encoding.  The columns of the table are as follows:
+#
+# 1.  ISO 3166-1 alpha-2 country code, current as of
+#     ISO/TC 46 N1108 (2023-04-05).  See: ISO/TC 46 Documents
+#     https://www.iso.org/committee/48750.html?view=documents
+# 2.  The usual English name for the coded region.  This sometimes
+#     departs from ISO-listed names, sometimes so that sorted subsets
+#     of names are useful (e.g., "Samoa (American)" and "Samoa
+#     (western)" rather than "American Samoa" and "Samoa"),
+#     sometimes to avoid confusion among non-experts (e.g.,
+#     "Czech Republic" and "Turkey" rather than "Czechia" and "Türkiye"),
+#     and sometimes to omit needless detail or churn (e.g., "Netherlands"
+#     rather than "Netherlands (the)" or "Netherlands (Kingdom of the)").
+#
+# The table is sorted by country code.
+#
+# This table is intended as an aid for users, to help them select time
+# zone data appropriate for their practical needs.  It is not intended
+# to take or endorse any position on legal or territorial claims.
+#
+#country-
+#code	name of country, territory, area, or subdivision
+AD	Andorra
+AE	United Arab Emirates
+AF	Afghanistan
+AG	Antigua & Barbuda
+AI	Anguilla
+AL	Albania
+AM	Armenia
+AO	Angola
+AQ	Antarctica
+AR	Argentina
+AS	Samoa (American)
+AT	Austria
+AU	Australia
+AW	Aruba
+AX	Åland Islands
+AZ	Azerbaijan
+BA	Bosnia & Herzegovina
+BB	Barbados
+BD	Bangladesh
+BE	Belgium
+BF	Burkina Faso
+BG	Bulgaria
+BH	Bahrain
+BI	Burundi
+BJ	Benin
+BL	St Barthelemy
+BM	Bermuda
+BN	Brunei
+BO	Bolivia
+BQ	Caribbean NL
+BR	Brazil
+BS	Bahamas
+BT	Bhutan
+BV	Bouvet Island
+BW	Botswana
+BY	Belarus
+BZ	Belize
+CA	Canada
+CC	Cocos (Keeling) Islands
+CD	Congo (Dem. Rep.)
+CF	Central African Rep.
+CG	Congo (Rep.)
+CH	Switzerland
+CI	Côte d'Ivoire
+CK	Cook Islands
+CL	Chile
+CM	Cameroon
+CN	China
+CO	Colombia
+CR	Costa Rica
+CU	Cuba
+CV	Cape Verde
+CW	Curaçao
+CX	Christmas Island
+CY	Cyprus
+CZ	Czech Republic
+DE	Germany
+DJ	Djibouti
+DK	Denmark
+DM	Dominica
+DO	Dominican Republic
+DZ	Algeria
+EC	Ecuador
+EE	Estonia
+EG	Egypt
+EH	Western Sahara
+ER	Eritrea
+ES	Spain
+ET	Ethiopia
+FI	Finland
+FJ	Fiji
+FK	Falkland Islands
+FM	Micronesia
+FO	Faroe Islands
+FR	France
+GA	Gabon
+GB	Britain (UK)
+GD	Grenada
+GE	Georgia
+GF	French Guiana
+GG	Guernsey
+GH	Ghana
+GI	Gibraltar
+GL	Greenland
+GM	Gambia
+GN	Guinea
+GP	Guadeloupe
+GQ	Equatorial Guinea
+GR	Greece
+GS	South Georgia & the South Sandwich Islands
+GT	Guatemala
+GU	Guam
+GW	Guinea-Bissau
+GY	Guyana
+HK	Hong Kong
+HM	Heard Island & McDonald Islands
+HN	Honduras
+HR	Croatia
+HT	Haiti
+HU	Hungary
+ID	Indonesia
+IE	Ireland
+IL	Israel
+IM	Isle of Man
+IN	India
+IO	British Indian Ocean Territory
+IQ	Iraq
+IR	Iran
+IS	Iceland
+IT	Italy
+JE	Jersey
+JM	Jamaica
+JO	Jordan
+JP	Japan
+KE	Kenya
+KG	Kyrgyzstan
+KH	Cambodia
+KI	Kiribati
+KM	Comoros
+KN	St Kitts & Nevis
+KP	Korea (North)
+KR	Korea (South)
+KW	Kuwait
+KY	Cayman Islands
+KZ	Kazakhstan
+LA	Laos
+LB	Lebanon
+LC	St Lucia
+LI	Liechtenstein
+LK	Sri Lanka
+LR	Liberia
+LS	Lesotho
+LT	Lithuania
+LU	Luxembourg
+LV	Latvia
+LY	Libya
+MA	Morocco
+MC	Monaco
+MD	Moldova
+ME	Montenegro
+MF	St Martin (French)
+MG	Madagascar
+MH	Marshall Islands
+MK	North Macedonia
+ML	Mali
+MM	Myanmar (Burma)
+MN	Mongolia
+MO	Macau
+MP	Northern Mariana Islands
+MQ	Martinique
+MR	Mauritania
+MS	Montserrat
+MT	Malta
+MU	Mauritius
+MV	Maldives
+MW	Malawi
+MX	Mexico
+MY	Malaysia
+MZ	Mozambique
+NA	Namibia
+NC	New Caledonia
+NE	Niger
+NF	Norfolk Island
+NG	Nigeria
+NI	Nicaragua
+NL	Netherlands
+NO	Norway
+NP	Nepal
+NR	Nauru
+NU	Niue
+NZ	New Zealand
+OM	Oman
+PA	Panama
+PE	Peru
+PF	French Polynesia
+PG	Papua New Guinea
+PH	Philippines
+PK	Pakistan
+PL	Poland
+PM	St Pierre & Miquelon
+PN	Pitcairn
+PR	Puerto Rico
+PS	Palestine
+PT	Portugal
+PW	Palau
+PY	Paraguay
+QA	Qatar
+RE	Réunion
+RO	Romania
+RS	Serbia
+RU	Russia
+RW	Rwanda
+SA	Saudi Arabia
+SB	Solomon Islands
+SC	Seychelles
+SD	Sudan
+SE	Sweden
+SG	Singapore
+SH	St Helena
+SI	Slovenia
+SJ	Svalbard & Jan Mayen
+SK	Slovakia
+SL	Sierra Leone
+SM	San Marino
+SN	Senegal
+SO	Somalia
+SR	Suriname
+SS	South Sudan
+ST	Sao Tome & Principe
+SV	El Salvador
+SX	St Maarten (Dutch)
+SY	Syria
+SZ	Eswatini (Swaziland)
+TC	Turks & Caicos Is
+TD	Chad
+TF	French S. Terr.
+TG	Togo
+TH	Thailand
+TJ	Tajikistan
+TK	Tokelau
+TL	East Timor
+TM	Turkmenistan
+TN	Tunisia
+TO	Tonga
+TR	Turkey
+TT	Trinidad & Tobago
+TV	Tuvalu
+TW	Taiwan
+TZ	Tanzania
+UA	Ukraine
+UG	Uganda
+UM	US minor outlying islands
+US	United States
+UY	Uruguay
+UZ	Uzbekistan
+VA	Vatican City
+VC	St Vincent
+VE	Venezuela
+VG	Virgin Islands (UK)
+VI	Virgin Islands (US)
+VN	Vietnam
+VU	Vanuatu
+WF	Wallis & Futuna
+WS	Samoa (western)
+YE	Yemen
+YT	Mayotte
+ZA	South Africa
+ZM	Zambia
+ZW	Zimbabwe
diff --git a/marketing/share/zoneinfo/leap-seconds.list b/marketing/share/zoneinfo/leap-seconds.list
new file mode 100644
index 0000000000000000000000000000000000000000..6f861c888d759d420dcb63533dde1579aff6a255
--- /dev/null
+++ b/marketing/share/zoneinfo/leap-seconds.list
@@ -0,0 +1,120 @@
+#	ATOMIC TIME
+#	Coordinated Universal Time (UTC) is the reference time scale derived
+#	from The "Temps Atomique International" (TAI) calculated by the Bureau
+#	International des Poids et Mesures (BIPM) using a worldwide network of atomic
+#	clocks. UTC differs from TAI by an integer number of seconds; it is the basis
+#	of all activities in the world.
+#
+#
+#	ASTRONOMICAL TIME (UT1) is the time scale based on the rate of rotation of the earth.
+#	It is now mainly derived from Very Long Baseline Interferometry (VLBI). The various
+#	irregular fluctuations progressively detected in the rotation rate of the Earth led
+#	in 1972 to the replacement of UT1 by UTC as the reference time scale.
+#
+#
+#	LEAP SECOND
+#	Atomic clocks are more stable than the rate of the earth's rotation since the latter
+#	undergoes a full range of geophysical perturbations at various time scales: lunisolar
+#	and core-mantle torques, atmospheric and oceanic effects, etc.
+#	Leap seconds are needed to keep the two time scales in agreement, i.e. UT1-UTC smaller
+#	than 0.9 seconds. Therefore, when necessary a "leap second" is applied to UTC.
+#	Since the adoption of this system in 1972 it has been necessary to add a number of seconds to UTC,
+#	firstly due to the initial choice of the value of the second (1/86400 mean solar day of
+#	the year 1820) and secondly to the general slowing down of the Earth's rotation. It is
+#	theoretically possible to have a negative leap second (a second removed from UTC), but so far,
+#	all leap seconds have been positive (a second has been added to UTC). Based on what we know about
+#	the earth's rotation, it is unlikely that we will ever have a negative leap second.
+#
+#
+#	HISTORY
+#	The first leap second was added on June 30, 1972. Until the year 2000, it was necessary in average to add a
+#       leap second at a rate of 1 to 2 years. Since the year 2000 leap seconds are introduced with an
+#	average interval of 3 to 4 years due to the acceleration of the Earth's rotation speed.
+#
+#
+#	RESPONSIBILITY OF THE DECISION TO INTRODUCE A LEAP SECOND IN UTC
+#	The decision to introduce a leap second in UTC is the responsibility of the Earth Orientation Center of
+#	the International Earth Rotation and reference System Service (IERS). This center is located at Paris
+#	Observatory. According to international agreements, leap seconds should be scheduled only for certain dates:
+#	first preference is given to the end of December and June, and second preference at the end of March
+#	and September. Since the introduction of leap seconds in 1972, only dates in June and December were used.
+#
+#		Questions or comments to:
+#			Christian Bizouard:  christian.bizouard@obspm.fr
+#			Earth orientation Center of the IERS
+#			Paris Observatory, France
+#
+#
+#
+#    	COPYRIGHT STATUS OF THIS FILE
+#    	This file is in the public domain.
+#
+#
+#	VALIDITY OF THE FILE
+#	It is important to express the validity of the file. These next two dates are
+#	given in units of seconds since 1900.0.
+#
+#	1) Last update of the file.
+#
+#	Updated through IERS Bulletin C (https://hpiers.obspm.fr/iers/bul/bulc/bulletinc.dat)
+#
+#	The following line shows the last update of this file in NTP timestamp:
+#
+#$	3945196800
+#
+#	2) Expiration date of the file given on a semi-annual basis: last June or last December
+#
+#	File expires on 28 December 2025
+#
+#	Expire date in NTP timestamp:
+#
+#@	3975868800
+#
+#
+#	LIST OF LEAP SECONDS
+#	NTP timestamp (X parameter) is the number of seconds since 1900.0
+#
+#	MJD: The Modified Julian Day number. MJD = X/86400 + 15020
+#
+#	DTAI: The difference DTAI= TAI-UTC in units of seconds
+#	It is the quantity to add to UTC to get the time in TAI
+#
+#	Day Month Year : epoch in clear
+#
+#NTP Time      DTAI    Day Month Year
+#
+2272060800      10      # 1 Jan 1972
+2287785600      11      # 1 Jul 1972
+2303683200      12      # 1 Jan 1973
+2335219200      13      # 1 Jan 1974
+2366755200      14      # 1 Jan 1975
+2398291200      15      # 1 Jan 1976
+2429913600      16      # 1 Jan 1977
+2461449600      17      # 1 Jan 1978
+2492985600      18      # 1 Jan 1979
+2524521600      19      # 1 Jan 1980
+2571782400      20      # 1 Jul 1981
+2603318400      21      # 1 Jul 1982
+2634854400      22      # 1 Jul 1983
+2698012800      23      # 1 Jul 1985
+2776982400      24      # 1 Jan 1988
+2840140800      25      # 1 Jan 1990
+2871676800      26      # 1 Jan 1991
+2918937600      27      # 1 Jul 1992
+2950473600      28      # 1 Jul 1993
+2982009600      29      # 1 Jul 1994
+3029443200      30      # 1 Jan 1996
+3076704000      31      # 1 Jul 1997
+3124137600      32      # 1 Jan 1999
+3345062400      33      # 1 Jan 2006
+3439756800      34      # 1 Jan 2009
+3550089600      35      # 1 Jul 2012
+3644697600      36      # 1 Jul 2015
+3692217600      37      # 1 Jan 2017
+#
+#	A hash code has been generated to be able to verify the integrity
+#	of this file. For more information about using this hash code,
+#	please see the readme file in the 'source' directory :
+#	https://hpiers.obspm.fr/iers/bul/bulc/ntp/sources/README
+#
+#h	848434d5 570f7ea8 d79ba227 a00fc821 f608e2d4
diff --git a/marketing/share/zoneinfo/leapseconds b/marketing/share/zoneinfo/leapseconds
new file mode 100644
index 0000000000000000000000000000000000000000..76f771427f25b91e6944ffd2fee6031bfd73979a
--- /dev/null
+++ b/marketing/share/zoneinfo/leapseconds
@@ -0,0 +1,79 @@
+# Allowance for leap seconds added to each time zone file.
+
+# This file is in the public domain.
+
+# This file is generated automatically from the data in the public-domain
+# NIST/IERS format leap-seconds.list file, which can be copied from
+# 
+# or, in a variant with different comments, from
+# .
+# For more about leap-seconds.list, please see
+# The NTP Timescale and Leap Seconds
+# .
+
+# The rules for leap seconds are specified in Annex 1 (Time scales) of:
+# Standard-frequency and time-signal emissions.
+# International Telecommunication Union - Radiocommunication Sector
+# (ITU-R) Recommendation TF.460-6 (02/2002)
+# .
+# The International Earth Rotation and Reference Systems Service (IERS)
+# periodically uses leap seconds to keep UTC to within 0.9 s of UT1
+# (a proxy for Earth's angle in space as measured by astronomers)
+# and publishes leap second data in a copyrighted file
+# .
+# See: Levine J. Coordinated Universal Time and the leap second.
+# URSI Radio Sci Bull. 2016;89(4):30-6. doi:10.23919/URSIRSB.2016.7909995
+# .
+
+# There were no leap seconds before 1972, as no official mechanism
+# accounted for the discrepancy between atomic time (TAI) and the earth's
+# rotation.  The first ("1 Jan 1972") data line in leap-seconds.list
+# does not denote a leap second; it denotes the start of the current definition
+# of UTC.
+
+# All leap-seconds are Stationary (S) at the given UTC time.
+# The correction (+ or -) is made at the given time, so in the unlikely
+# event of a negative leap second, a line would look like this:
+# Leap	YEAR	MON	DAY	23:59:59	-	S
+# Typical lines look like this:
+# Leap	YEAR	MON	DAY	23:59:60	+	S
+Leap	1972	Jun	30	23:59:60	+	S
+Leap	1972	Dec	31	23:59:60	+	S
+Leap	1973	Dec	31	23:59:60	+	S
+Leap	1974	Dec	31	23:59:60	+	S
+Leap	1975	Dec	31	23:59:60	+	S
+Leap	1976	Dec	31	23:59:60	+	S
+Leap	1977	Dec	31	23:59:60	+	S
+Leap	1978	Dec	31	23:59:60	+	S
+Leap	1979	Dec	31	23:59:60	+	S
+Leap	1981	Jun	30	23:59:60	+	S
+Leap	1982	Jun	30	23:59:60	+	S
+Leap	1983	Jun	30	23:59:60	+	S
+Leap	1985	Jun	30	23:59:60	+	S
+Leap	1987	Dec	31	23:59:60	+	S
+Leap	1989	Dec	31	23:59:60	+	S
+Leap	1990	Dec	31	23:59:60	+	S
+Leap	1992	Jun	30	23:59:60	+	S
+Leap	1993	Jun	30	23:59:60	+	S
+Leap	1994	Jun	30	23:59:60	+	S
+Leap	1995	Dec	31	23:59:60	+	S
+Leap	1997	Jun	30	23:59:60	+	S
+Leap	1998	Dec	31	23:59:60	+	S
+Leap	2005	Dec	31	23:59:60	+	S
+Leap	2008	Dec	31	23:59:60	+	S
+Leap	2012	Jun	30	23:59:60	+	S
+Leap	2015	Jun	30	23:59:60	+	S
+Leap	2016	Dec	31	23:59:60	+	S
+
+# UTC timestamp when this leap second list expires.
+# Any additional leap seconds will come after this.
+# This Expires line is commented out for now,
+# so that pre-2020a zic implementations do not reject this file.
+#Expires 2025	Dec	28	00:00:00
+
+# POSIX timestamps for the data in this file:
+#updated 1736208000 (2025-01-07 00:00:00 UTC)
+#expires 1766880000 (2025-12-28 00:00:00 UTC)
+
+#	Updated through IERS Bulletin C (https://hpiers.obspm.fr/iers/bul/bulc/bulletinc.dat)
+#	File expires on 28 December 2025
diff --git a/marketing/share/zoneinfo/tzdata.zi b/marketing/share/zoneinfo/tzdata.zi
new file mode 100644
index 0000000000000000000000000000000000000000..db6ba4af2b013d9886dd3b81dd4f7f0b34ebbb02
--- /dev/null
+++ b/marketing/share/zoneinfo/tzdata.zi
@@ -0,0 +1,4286 @@
+# version 2025a
+# This zic input file is in the public domain.
+R d 1916 o - Jun 14 23s 1 S
+R d 1916 1919 - O Su>=1 23s 0 -
+R d 1917 o - Mar 24 23s 1 S
+R d 1918 o - Mar 9 23s 1 S
+R d 1919 o - Mar 1 23s 1 S
+R d 1920 o - F 14 23s 1 S
+R d 1920 o - O 23 23s 0 -
+R d 1921 o - Mar 14 23s 1 S
+R d 1921 o - Jun 21 23s 0 -
+R d 1939 o - S 11 23s 1 S
+R d 1939 o - N 19 1 0 -
+R d 1944 1945 - Ap M>=1 2 1 S
+R d 1944 o - O 8 2 0 -
+R d 1945 o - S 16 1 0 -
+R d 1971 o - Ap 25 23s 1 S
+R d 1971 o - S 26 23s 0 -
+R d 1977 o - May 6 0 1 S
+R d 1977 o - O 21 0 0 -
+R d 1978 o - Mar 24 1 1 S
+R d 1978 o - S 22 3 0 -
+R d 1980 o - Ap 25 0 1 S
+R d 1980 o - O 31 2 0 -
+R K 1940 o - Jul 15 0 1 S
+R K 1940 o - O 1 0 0 -
+R K 1941 o - Ap 15 0 1 S
+R K 1941 o - S 16 0 0 -
+R K 1942 1944 - Ap 1 0 1 S
+R K 1942 o - O 27 0 0 -
+R K 1943 1945 - N 1 0 0 -
+R K 1945 o - Ap 16 0 1 S
+R K 1957 o - May 10 0 1 S
+R K 1957 1958 - O 1 0 0 -
+R K 1958 o - May 1 0 1 S
+R K 1959 1981 - May 1 1 1 S
+R K 1959 1965 - S 30 3 0 -
+R K 1966 1994 - O 1 3 0 -
+R K 1982 o - Jul 25 1 1 S
+R K 1983 o - Jul 12 1 1 S
+R K 1984 1988 - May 1 1 1 S
+R K 1989 o - May 6 1 1 S
+R K 1990 1994 - May 1 1 1 S
+R K 1995 2010 - Ap lastF 0s 1 S
+R K 1995 2005 - S lastTh 24 0 -
+R K 2006 o - S 21 24 0 -
+R K 2007 o - S Th>=1 24 0 -
+R K 2008 o - Au lastTh 24 0 -
+R K 2009 o - Au 20 24 0 -
+R K 2010 o - Au 10 24 0 -
+R K 2010 o - S 9 24 1 S
+R K 2010 o - S lastTh 24 0 -
+R K 2014 o - May 15 24 1 S
+R K 2014 o - Jun 26 24 0 -
+R K 2014 o - Jul 31 24 1 S
+R K 2014 o - S lastTh 24 0 -
+R K 2023 ma - Ap lastF 0 1 S
+R K 2023 ma - O lastTh 24 0 -
+R L 1951 o - O 14 2 1 S
+R L 1952 o - Ja 1 0 0 -
+R L 1953 o - O 9 2 1 S
+R L 1954 o - Ja 1 0 0 -
+R L 1955 o - S 30 0 1 S
+R L 1956 o - Ja 1 0 0 -
+R L 1982 1984 - Ap 1 0 1 S
+R L 1982 1985 - O 1 0 0 -
+R L 1985 o - Ap 6 0 1 S
+R L 1986 o - Ap 4 0 1 S
+R L 1986 o - O 3 0 0 -
+R L 1987 1989 - Ap 1 0 1 S
+R L 1987 1989 - O 1 0 0 -
+R L 1997 o - Ap 4 0 1 S
+R L 1997 o - O 4 0 0 -
+R L 2013 o - Mar lastF 1 1 S
+R L 2013 o - O lastF 2 0 -
+R MU 1982 o - O 10 0 1 -
+R MU 1983 o - Mar 21 0 0 -
+R MU 2008 o - O lastSu 2 1 -
+R MU 2009 o - Mar lastSu 2 0 -
+R M 1939 o - S 12 0 1 -
+R M 1939 o - N 19 0 0 -
+R M 1940 o - F 25 0 1 -
+R M 1945 o - N 18 0 0 -
+R M 1950 o - Jun 11 0 1 -
+R M 1950 o - O 29 0 0 -
+R M 1967 o - Jun 3 12 1 -
+R M 1967 o - O 1 0 0 -
+R M 1974 o - Jun 24 0 1 -
+R M 1974 o - S 1 0 0 -
+R M 1976 1977 - May 1 0 1 -
+R M 1976 o - Au 1 0 0 -
+R M 1977 o - S 28 0 0 -
+R M 1978 o - Jun 1 0 1 -
+R M 1978 o - Au 4 0 0 -
+R M 2008 o - Jun 1 0 1 -
+R M 2008 o - S 1 0 0 -
+R M 2009 o - Jun 1 0 1 -
+R M 2009 o - Au 21 0 0 -
+R M 2010 o - May 2 0 1 -
+R M 2010 o - Au 8 0 0 -
+R M 2011 o - Ap 3 0 1 -
+R M 2011 o - Jul 31 0 0 -
+R M 2012 2013 - Ap lastSu 2 1 -
+R M 2012 o - Jul 20 3 0 -
+R M 2012 o - Au 20 2 1 -
+R M 2012 o - S 30 3 0 -
+R M 2013 o - Jul 7 3 0 -
+R M 2013 o - Au 10 2 1 -
+R M 2013 2018 - O lastSu 3 0 -
+R M 2014 2018 - Mar lastSu 2 1 -
+R M 2014 o - Jun 28 3 0 -
+R M 2014 o - Au 2 2 1 -
+R M 2015 o - Jun 14 3 0 -
+R M 2015 o - Jul 19 2 1 -
+R M 2016 o - Jun 5 3 0 -
+R M 2016 o - Jul 10 2 1 -
+R M 2017 o - May 21 3 0 -
+R M 2017 o - Jul 2 2 1 -
+R M 2018 o - May 13 3 0 -
+R M 2018 o - Jun 17 2 1 -
+R M 2019 o - May 5 3 -1 -
+R M 2019 o - Jun 9 2 0 -
+R M 2020 o - Ap 19 3 -1 -
+R M 2020 o - May 31 2 0 -
+R M 2021 o - Ap 11 3 -1 -
+R M 2021 o - May 16 2 0 -
+R M 2022 o - Mar 27 3 -1 -
+R M 2022 o - May 8 2 0 -
+R M 2023 o - Mar 19 3 -1 -
+R M 2023 o - Ap 23 2 0 -
+R M 2024 o - Mar 10 3 -1 -
+R M 2024 o - Ap 14 2 0 -
+R M 2025 o - F 23 3 -1 -
+R M 2025 o - Ap 6 2 0 -
+R M 2026 o - F 15 3 -1 -
+R M 2026 o - Mar 22 2 0 -
+R M 2027 o - F 7 3 -1 -
+R M 2027 o - Mar 14 2 0 -
+R M 2028 o - Ja 23 3 -1 -
+R M 2028 o - Mar 5 2 0 -
+R M 2029 o - Ja 14 3 -1 -
+R M 2029 o - F 18 2 0 -
+R M 2029 o - D 30 3 -1 -
+R M 2030 o - F 10 2 0 -
+R M 2030 o - D 22 3 -1 -
+R M 2031 o - Ja 26 2 0 -
+R M 2031 o - D 14 3 -1 -
+R M 2032 o - Ja 18 2 0 -
+R M 2032 o - N 28 3 -1 -
+R M 2033 o - Ja 9 2 0 -
+R M 2033 o - N 20 3 -1 -
+R M 2033 o - D 25 2 0 -
+R M 2034 o - N 5 3 -1 -
+R M 2034 o - D 17 2 0 -
+R M 2035 o - O 28 3 -1 -
+R M 2035 o - D 9 2 0 -
+R M 2036 o - O 19 3 -1 -
+R M 2036 o - N 23 2 0 -
+R M 2037 o - O 4 3 -1 -
+R M 2037 o - N 15 2 0 -
+R M 2038 o - S 26 3 -1 -
+R M 2038 o - O 31 2 0 -
+R M 2039 o - S 18 3 -1 -
+R M 2039 o - O 23 2 0 -
+R M 2040 o - S 2 3 -1 -
+R M 2040 o - O 14 2 0 -
+R M 2041 o - Au 25 3 -1 -
+R M 2041 o - S 29 2 0 -
+R M 2042 o - Au 10 3 -1 -
+R M 2042 o - S 21 2 0 -
+R M 2043 o - Au 2 3 -1 -
+R M 2043 o - S 13 2 0 -
+R M 2044 o - Jul 24 3 -1 -
+R M 2044 o - Au 28 2 0 -
+R M 2045 o - Jul 9 3 -1 -
+R M 2045 o - Au 20 2 0 -
+R M 2046 o - Jul 1 3 -1 -
+R M 2046 o - Au 5 2 0 -
+R M 2047 o - Jun 23 3 -1 -
+R M 2047 o - Jul 28 2 0 -
+R M 2048 o - Jun 7 3 -1 -
+R M 2048 o - Jul 19 2 0 -
+R M 2049 o - May 30 3 -1 -
+R M 2049 o - Jul 4 2 0 -
+R M 2050 o - May 15 3 -1 -
+R M 2050 o - Jun 26 2 0 -
+R M 2051 o - May 7 3 -1 -
+R M 2051 o - Jun 18 2 0 -
+R M 2052 o - Ap 28 3 -1 -
+R M 2052 o - Jun 2 2 0 -
+R M 2053 o - Ap 13 3 -1 -
+R M 2053 o - May 25 2 0 -
+R M 2054 o - Ap 5 3 -1 -
+R M 2054 o - May 10 2 0 -
+R M 2055 o - Mar 28 3 -1 -
+R M 2055 o - May 2 2 0 -
+R M 2056 o - Mar 12 3 -1 -
+R M 2056 o - Ap 23 2 0 -
+R M 2057 o - Mar 4 3 -1 -
+R M 2057 o - Ap 8 2 0 -
+R M 2058 o - F 17 3 -1 -
+R M 2058 o - Mar 31 2 0 -
+R M 2059 o - F 9 3 -1 -
+R M 2059 o - Mar 23 2 0 -
+R M 2060 o - F 1 3 -1 -
+R M 2060 o - Mar 7 2 0 -
+R M 2061 o - Ja 16 3 -1 -
+R M 2061 o - F 27 2 0 -
+R M 2062 o - Ja 8 3 -1 -
+R M 2062 o - F 12 2 0 -
+R M 2062 o - D 31 3 -1 -
+R M 2063 o - F 4 2 0 -
+R M 2063 o - D 16 3 -1 -
+R M 2064 o - Ja 27 2 0 -
+R M 2064 o - D 7 3 -1 -
+R M 2065 o - Ja 11 2 0 -
+R M 2065 o - N 22 3 -1 -
+R M 2066 o - Ja 3 2 0 -
+R M 2066 o - N 14 3 -1 -
+R M 2066 o - D 26 2 0 -
+R M 2067 o - N 6 3 -1 -
+R M 2067 o - D 11 2 0 -
+R M 2068 o - O 21 3 -1 -
+R M 2068 o - D 2 2 0 -
+R M 2069 o - O 13 3 -1 -
+R M 2069 o - N 17 2 0 -
+R M 2070 o - O 5 3 -1 -
+R M 2070 o - N 9 2 0 -
+R M 2071 o - S 20 3 -1 -
+R M 2071 o - N 1 2 0 -
+R M 2072 o - S 11 3 -1 -
+R M 2072 o - O 16 2 0 -
+R M 2073 o - Au 27 3 -1 -
+R M 2073 o - O 8 2 0 -
+R M 2074 o - Au 19 3 -1 -
+R M 2074 o - S 30 2 0 -
+R M 2075 o - Au 11 3 -1 -
+R M 2075 o - S 15 2 0 -
+R M 2076 o - Jul 26 3 -1 -
+R M 2076 o - S 6 2 0 -
+R M 2077 o - Jul 18 3 -1 -
+R M 2077 o - Au 22 2 0 -
+R M 2078 o - Jul 10 3 -1 -
+R M 2078 o - Au 14 2 0 -
+R M 2079 o - Jun 25 3 -1 -
+R M 2079 o - Au 6 2 0 -
+R M 2080 o - Jun 16 3 -1 -
+R M 2080 o - Jul 21 2 0 -
+R M 2081 o - Jun 1 3 -1 -
+R M 2081 o - Jul 13 2 0 -
+R M 2082 o - May 24 3 -1 -
+R M 2082 o - Jun 28 2 0 -
+R M 2083 o - May 16 3 -1 -
+R M 2083 o - Jun 20 2 0 -
+R M 2084 o - Ap 30 3 -1 -
+R M 2084 o - Jun 11 2 0 -
+R M 2085 o - Ap 22 3 -1 -
+R M 2085 o - May 27 2 0 -
+R M 2086 o - Ap 14 3 -1 -
+R M 2086 o - May 19 2 0 -
+R M 2087 o - Mar 30 3 -1 -
+R M 2087 o - May 11 2 0 -
+R NA 1994 o - Mar 21 0 -1 WAT
+R NA 1994 2017 - S Su>=1 2 0 CAT
+R NA 1995 2017 - Ap Su>=1 2 -1 WAT
+R SA 1942 1943 - S Su>=15 2 1 -
+R SA 1943 1944 - Mar Su>=15 2 0 -
+R SD 1970 o - May 1 0 1 S
+R SD 1970 1985 - O 15 0 0 -
+R SD 1971 o - Ap 30 0 1 S
+R SD 1972 1985 - Ap lastSu 0 1 S
+R n 1939 o - Ap 15 23s 1 S
+R n 1939 o - N 18 23s 0 -
+R n 1940 o - F 25 23s 1 S
+R n 1941 o - O 6 0 0 -
+R n 1942 o - Mar 9 0 1 S
+R n 1942 o - N 2 3 0 -
+R n 1943 o - Mar 29 2 1 S
+R n 1943 o - Ap 17 2 0 -
+R n 1943 o - Ap 25 2 1 S
+R n 1943 o - O 4 2 0 -
+R n 1944 1945 - Ap M>=1 2 1 S
+R n 1944 o - O 8 0 0 -
+R n 1945 o - S 16 0 0 -
+R n 1977 o - Ap 30 0s 1 S
+R n 1977 o - S 24 0s 0 -
+R n 1978 o - May 1 0s 1 S
+R n 1978 o - O 1 0s 0 -
+R n 1988 o - Jun 1 0s 1 S
+R n 1988 1990 - S lastSu 0s 0 -
+R n 1989 o - Mar 26 0s 1 S
+R n 1990 o - May 1 0s 1 S
+R n 2005 o - May 1 0s 1 S
+R n 2005 o - S 30 1s 0 -
+R n 2006 2008 - Mar lastSu 2s 1 S
+R n 2006 2008 - O lastSu 2s 0 -
+R Tr 2005 ma - Mar lastSu 1u 2 +02
+R Tr 2004 ma - O lastSu 1u 0 +00
+R AM 2011 o - Mar lastSu 2s 1 -
+R AM 2011 o - O lastSu 2s 0 -
+R AZ 1997 2015 - Mar lastSu 4 1 -
+R AZ 1997 2015 - O lastSu 5 0 -
+R BD 2009 o - Jun 19 23 1 -
+R BD 2009 o - D 31 24 0 -
+R Sh 1919 o - Ap 12 24 1 D
+R Sh 1919 o - S 30 24 0 S
+R Sh 1940 o - Jun 1 0 1 D
+R Sh 1940 o - O 12 24 0 S
+R Sh 1941 o - Mar 15 0 1 D
+R Sh 1941 o - N 1 24 0 S
+R Sh 1942 o - Ja 31 0 1 D
+R Sh 1945 o - S 1 24 0 S
+R Sh 1946 o - May 15 0 1 D
+R Sh 1946 o - S 30 24 0 S
+R Sh 1947 o - Ap 15 0 1 D
+R Sh 1947 o - O 31 24 0 S
+R Sh 1948 1949 - May 1 0 1 D
+R Sh 1948 1949 - S 30 24 0 S
+R CN 1986 o - May 4 2 1 D
+R CN 1986 1991 - S Su>=11 2 0 S
+R CN 1987 1991 - Ap Su>=11 2 1 D
+R HK 1946 o - Ap 21 0 1 S
+R HK 1946 o - D 1 3:30s 0 -
+R HK 1947 o - Ap 13 3:30s 1 S
+R HK 1947 o - N 30 3:30s 0 -
+R HK 1948 o - May 2 3:30s 1 S
+R HK 1948 1952 - O Su>=28 3:30s 0 -
+R HK 1949 1953 - Ap Su>=1 3:30 1 S
+R HK 1953 1964 - O Su>=31 3:30 0 -
+R HK 1954 1964 - Mar Su>=18 3:30 1 S
+R HK 1965 1976 - Ap Su>=16 3:30 1 S
+R HK 1965 1976 - O Su>=16 3:30 0 -
+R HK 1973 o - D 30 3:30 1 S
+R HK 1979 o - May 13 3:30 1 S
+R HK 1979 o - O 21 3:30 0 -
+R f 1946 o - May 15 0 1 D
+R f 1946 o - O 1 0 0 S
+R f 1947 o - Ap 15 0 1 D
+R f 1947 o - N 1 0 0 S
+R f 1948 1951 - May 1 0 1 D
+R f 1948 1951 - O 1 0 0 S
+R f 1952 o - Mar 1 0 1 D
+R f 1952 1954 - N 1 0 0 S
+R f 1953 1959 - Ap 1 0 1 D
+R f 1955 1961 - O 1 0 0 S
+R f 1960 1961 - Jun 1 0 1 D
+R f 1974 1975 - Ap 1 0 1 D
+R f 1974 1975 - O 1 0 0 S
+R f 1979 o - Jul 1 0 1 D
+R f 1979 o - O 1 0 0 S
+R _ 1942 1943 - Ap 30 23 1 -
+R _ 1942 o - N 17 23 0 -
+R _ 1943 o - S 30 23 0 S
+R _ 1946 o - Ap 30 23s 1 D
+R _ 1946 o - S 30 23s 0 S
+R _ 1947 o - Ap 19 23s 1 D
+R _ 1947 o - N 30 23s 0 S
+R _ 1948 o - May 2 23s 1 D
+R _ 1948 o - O 31 23s 0 S
+R _ 1949 1950 - Ap Sa>=1 23s 1 D
+R _ 1949 1950 - O lastSa 23s 0 S
+R _ 1951 o - Mar 31 23s 1 D
+R _ 1951 o - O 28 23s 0 S
+R _ 1952 1953 - Ap Sa>=1 23s 1 D
+R _ 1952 o - N 1 23s 0 S
+R _ 1953 1954 - O lastSa 23s 0 S
+R _ 1954 1956 - Mar Sa>=17 23s 1 D
+R _ 1955 o - N 5 23s 0 S
+R _ 1956 1964 - N Su>=1 3:30 0 S
+R _ 1957 1964 - Mar Su>=18 3:30 1 D
+R _ 1965 1973 - Ap Su>=16 3:30 1 D
+R _ 1965 1966 - O Su>=16 2:30 0 S
+R _ 1967 1976 - O Su>=16 3:30 0 S
+R _ 1973 o - D 30 3:30 1 D
+R _ 1975 1976 - Ap Su>=16 3:30 1 D
+R _ 1979 o - May 13 3:30 1 D
+R _ 1979 o - O Su>=16 3:30 0 S
+R CY 1975 o - Ap 13 0 1 S
+R CY 1975 o - O 12 0 0 -
+R CY 1976 o - May 15 0 1 S
+R CY 1976 o - O 11 0 0 -
+R CY 1977 1980 - Ap Su>=1 0 1 S
+R CY 1977 o - S 25 0 0 -
+R CY 1978 o - O 2 0 0 -
+R CY 1979 1997 - S lastSu 0 0 -
+R CY 1981 1998 - Mar lastSu 0 1 S
+R i 1910 o - Ja 1 0 0 -
+R i 1977 o - Mar 21 23 1 -
+R i 1977 o - O 20 24 0 -
+R i 1978 o - Mar 24 24 1 -
+R i 1978 o - Au 5 1 0 -
+R i 1979 o - May 26 24 1 -
+R i 1979 o - S 18 24 0 -
+R i 1980 o - Mar 20 24 1 -
+R i 1980 o - S 22 24 0 -
+R i 1991 o - May 2 24 1 -
+R i 1992 1995 - Mar 21 24 1 -
+R i 1991 1995 - S 21 24 0 -
+R i 1996 o - Mar 20 24 1 -
+R i 1996 o - S 20 24 0 -
+R i 1997 1999 - Mar 21 24 1 -
+R i 1997 1999 - S 21 24 0 -
+R i 2000 o - Mar 20 24 1 -
+R i 2000 o - S 20 24 0 -
+R i 2001 2003 - Mar 21 24 1 -
+R i 2001 2003 - S 21 24 0 -
+R i 2004 o - Mar 20 24 1 -
+R i 2004 o - S 20 24 0 -
+R i 2005 o - Mar 21 24 1 -
+R i 2005 o - S 21 24 0 -
+R i 2008 o - Mar 20 24 1 -
+R i 2008 o - S 20 24 0 -
+R i 2009 2011 - Mar 21 24 1 -
+R i 2009 2011 - S 21 24 0 -
+R i 2012 o - Mar 20 24 1 -
+R i 2012 o - S 20 24 0 -
+R i 2013 2015 - Mar 21 24 1 -
+R i 2013 2015 - S 21 24 0 -
+R i 2016 o - Mar 20 24 1 -
+R i 2016 o - S 20 24 0 -
+R i 2017 2019 - Mar 21 24 1 -
+R i 2017 2019 - S 21 24 0 -
+R i 2020 o - Mar 20 24 1 -
+R i 2020 o - S 20 24 0 -
+R i 2021 2022 - Mar 21 24 1 -
+R i 2021 2022 - S 21 24 0 -
+R IQ 1982 o - May 1 0 1 -
+R IQ 1982 1984 - O 1 0 0 -
+R IQ 1983 o - Mar 31 0 1 -
+R IQ 1984 1985 - Ap 1 0 1 -
+R IQ 1985 1990 - S lastSu 1s 0 -
+R IQ 1986 1990 - Mar lastSu 1s 1 -
+R IQ 1991 2007 - Ap 1 3s 1 -
+R IQ 1991 2007 - O 1 3s 0 -
+R Z 1940 o - May 31 24u 1 D
+R Z 1940 o - S 30 24u 0 S
+R Z 1940 o - N 16 24u 1 D
+R Z 1942 1946 - O 31 24u 0 S
+R Z 1943 1944 - Mar 31 24u 1 D
+R Z 1945 1946 - Ap 15 24u 1 D
+R Z 1948 o - May 22 24u 2 DD
+R Z 1948 o - Au 31 24u 1 D
+R Z 1948 1949 - O 31 24u 0 S
+R Z 1949 o - Ap 30 24u 1 D
+R Z 1950 o - Ap 15 24u 1 D
+R Z 1950 o - S 14 24u 0 S
+R Z 1951 o - Mar 31 24u 1 D
+R Z 1951 o - N 10 24u 0 S
+R Z 1952 o - Ap 19 24u 1 D
+R Z 1952 o - O 18 24u 0 S
+R Z 1953 o - Ap 11 24u 1 D
+R Z 1953 o - S 12 24u 0 S
+R Z 1954 o - Jun 12 24u 1 D
+R Z 1954 o - S 11 24u 0 S
+R Z 1955 o - Jun 11 24u 1 D
+R Z 1955 o - S 10 24u 0 S
+R Z 1956 o - Jun 2 24u 1 D
+R Z 1956 o - S 29 24u 0 S
+R Z 1957 o - Ap 27 24u 1 D
+R Z 1957 o - S 21 24u 0 S
+R Z 1974 o - Jul 6 24 1 D
+R Z 1974 o - O 12 24 0 S
+R Z 1975 o - Ap 19 24 1 D
+R Z 1975 o - Au 30 24 0 S
+R Z 1980 o - Au 2 24s 1 D
+R Z 1980 o - S 13 24s 0 S
+R Z 1984 o - May 5 24s 1 D
+R Z 1984 o - Au 25 24s 0 S
+R Z 1985 o - Ap 13 24 1 D
+R Z 1985 o - Au 31 24 0 S
+R Z 1986 o - May 17 24 1 D
+R Z 1986 o - S 6 24 0 S
+R Z 1987 o - Ap 14 24 1 D
+R Z 1987 o - S 12 24 0 S
+R Z 1988 o - Ap 9 24 1 D
+R Z 1988 o - S 3 24 0 S
+R Z 1989 o - Ap 29 24 1 D
+R Z 1989 o - S 2 24 0 S
+R Z 1990 o - Mar 24 24 1 D
+R Z 1990 o - Au 25 24 0 S
+R Z 1991 o - Mar 23 24 1 D
+R Z 1991 o - Au 31 24 0 S
+R Z 1992 o - Mar 28 24 1 D
+R Z 1992 o - S 5 24 0 S
+R Z 1993 o - Ap 2 0 1 D
+R Z 1993 o - S 5 0 0 S
+R Z 1994 o - Ap 1 0 1 D
+R Z 1994 o - Au 28 0 0 S
+R Z 1995 o - Mar 31 0 1 D
+R Z 1995 o - S 3 0 0 S
+R Z 1996 o - Mar 14 24 1 D
+R Z 1996 o - S 15 24 0 S
+R Z 1997 o - Mar 20 24 1 D
+R Z 1997 o - S 13 24 0 S
+R Z 1998 o - Mar 20 0 1 D
+R Z 1998 o - S 6 0 0 S
+R Z 1999 o - Ap 2 2 1 D
+R Z 1999 o - S 3 2 0 S
+R Z 2000 o - Ap 14 2 1 D
+R Z 2000 o - O 6 1 0 S
+R Z 2001 o - Ap 9 1 1 D
+R Z 2001 o - S 24 1 0 S
+R Z 2002 o - Mar 29 1 1 D
+R Z 2002 o - O 7 1 0 S
+R Z 2003 o - Mar 28 1 1 D
+R Z 2003 o - O 3 1 0 S
+R Z 2004 o - Ap 7 1 1 D
+R Z 2004 o - S 22 1 0 S
+R Z 2005 2012 - Ap F<=1 2 1 D
+R Z 2005 o - O 9 2 0 S
+R Z 2006 o - O 1 2 0 S
+R Z 2007 o - S 16 2 0 S
+R Z 2008 o - O 5 2 0 S
+R Z 2009 o - S 27 2 0 S
+R Z 2010 o - S 12 2 0 S
+R Z 2011 o - O 2 2 0 S
+R Z 2012 o - S 23 2 0 S
+R Z 2013 ma - Mar F>=23 2 1 D
+R Z 2013 ma - O lastSu 2 0 S
+R JP 1948 o - May Sa>=1 24 1 D
+R JP 1948 1951 - S Sa>=8 25 0 S
+R JP 1949 o - Ap Sa>=1 24 1 D
+R JP 1950 1951 - May Sa>=1 24 1 D
+R J 1973 o - Jun 6 0 1 S
+R J 1973 1975 - O 1 0 0 -
+R J 1974 1977 - May 1 0 1 S
+R J 1976 o - N 1 0 0 -
+R J 1977 o - O 1 0 0 -
+R J 1978 o - Ap 30 0 1 S
+R J 1978 o - S 30 0 0 -
+R J 1985 o - Ap 1 0 1 S
+R J 1985 o - O 1 0 0 -
+R J 1986 1988 - Ap F>=1 0 1 S
+R J 1986 1990 - O F>=1 0 0 -
+R J 1989 o - May 8 0 1 S
+R J 1990 o - Ap 27 0 1 S
+R J 1991 o - Ap 17 0 1 S
+R J 1991 o - S 27 0 0 -
+R J 1992 o - Ap 10 0 1 S
+R J 1992 1993 - O F>=1 0 0 -
+R J 1993 1998 - Ap F>=1 0 1 S
+R J 1994 o - S F>=15 0 0 -
+R J 1995 1998 - S F>=15 0s 0 -
+R J 1999 o - Jul 1 0s 1 S
+R J 1999 2002 - S lastF 0s 0 -
+R J 2000 2001 - Mar lastTh 0s 1 S
+R J 2002 2012 - Mar lastTh 24 1 S
+R J 2003 o - O 24 0s 0 -
+R J 2004 o - O 15 0s 0 -
+R J 2005 o - S lastF 0s 0 -
+R J 2006 2011 - O lastF 0s 0 -
+R J 2013 o - D 20 0 0 -
+R J 2014 2021 - Mar lastTh 24 1 S
+R J 2014 2022 - O lastF 0s 0 -
+R J 2022 o - F lastTh 24 1 S
+R KG 1992 1996 - Ap Su>=7 0s 1 -
+R KG 1992 1996 - S lastSu 0 0 -
+R KG 1997 2005 - Mar lastSu 2:30 1 -
+R KG 1997 2004 - O lastSu 2:30 0 -
+R KR 1948 o - Jun 1 0 1 D
+R KR 1948 o - S 12 24 0 S
+R KR 1949 o - Ap 3 0 1 D
+R KR 1949 1951 - S Sa>=7 24 0 S
+R KR 1950 o - Ap 1 0 1 D
+R KR 1951 o - May 6 0 1 D
+R KR 1955 o - May 5 0 1 D
+R KR 1955 o - S 8 24 0 S
+R KR 1956 o - May 20 0 1 D
+R KR 1956 o - S 29 24 0 S
+R KR 1957 1960 - May Su>=1 0 1 D
+R KR 1957 1960 - S Sa>=17 24 0 S
+R KR 1987 1988 - May Su>=8 2 1 D
+R KR 1987 1988 - O Su>=8 3 0 S
+R l 1920 o - Mar 28 0 1 S
+R l 1920 o - O 25 0 0 -
+R l 1921 o - Ap 3 0 1 S
+R l 1921 o - O 3 0 0 -
+R l 1922 o - Mar 26 0 1 S
+R l 1922 o - O 8 0 0 -
+R l 1923 o - Ap 22 0 1 S
+R l 1923 o - S 16 0 0 -
+R l 1957 1961 - May 1 0 1 S
+R l 1957 1961 - O 1 0 0 -
+R l 1972 o - Jun 22 0 1 S
+R l 1972 1977 - O 1 0 0 -
+R l 1973 1977 - May 1 0 1 S
+R l 1978 o - Ap 30 0 1 S
+R l 1978 o - S 30 0 0 -
+R l 1984 1987 - May 1 0 1 S
+R l 1984 1991 - O 16 0 0 -
+R l 1988 o - Jun 1 0 1 S
+R l 1989 o - May 10 0 1 S
+R l 1990 1992 - May 1 0 1 S
+R l 1992 o - O 4 0 0 -
+R l 1993 ma - Mar lastSu 0 1 S
+R l 1993 1998 - S lastSu 0 0 -
+R l 1999 ma - O lastSu 0 0 -
+R NB 1935 1941 - S 14 0 0:20 -
+R NB 1935 1941 - D 14 0 0 -
+R X 1983 1984 - Ap 1 0 1 -
+R X 1983 o - O 1 0 0 -
+R X 1985 1998 - Mar lastSu 0 1 -
+R X 1984 1998 - S lastSu 0 0 -
+R X 2001 o - Ap lastSa 2 1 -
+R X 2001 2006 - S lastSa 2 0 -
+R X 2002 2006 - Mar lastSa 2 1 -
+R X 2015 2016 - Mar lastSa 2 1 -
+R X 2015 2016 - S lastSa 0 0 -
+R PK 2002 o - Ap Su>=2 0 1 S
+R PK 2002 o - O Su>=2 0 0 -
+R PK 2008 o - Jun 1 0 1 S
+R PK 2008 2009 - N 1 0 0 -
+R PK 2009 o - Ap 15 0 1 S
+R P 1999 2005 - Ap F>=15 0 1 S
+R P 1999 2003 - O F>=15 0 0 -
+R P 2004 o - O 1 1 0 -
+R P 2005 o - O 4 2 0 -
+R P 2006 2007 - Ap 1 0 1 S
+R P 2006 o - S 22 0 0 -
+R P 2007 o - S 13 2 0 -
+R P 2008 2009 - Mar lastF 0 1 S
+R P 2008 o - S 1 0 0 -
+R P 2009 o - S 4 1 0 -
+R P 2010 o - Mar 26 0 1 S
+R P 2010 o - Au 11 0 0 -
+R P 2011 o - Ap 1 0:1 1 S
+R P 2011 o - Au 1 0 0 -
+R P 2011 o - Au 30 0 1 S
+R P 2011 o - S 30 0 0 -
+R P 2012 2014 - Mar lastTh 24 1 S
+R P 2012 o - S 21 1 0 -
+R P 2013 o - S 27 0 0 -
+R P 2014 o - O 24 0 0 -
+R P 2015 o - Mar 28 0 1 S
+R P 2015 o - O 23 1 0 -
+R P 2016 2018 - Mar Sa<=30 1 1 S
+R P 2016 2018 - O Sa<=30 1 0 -
+R P 2019 o - Mar 29 0 1 S
+R P 2019 o - O Sa<=30 0 0 -
+R P 2020 2021 - Mar Sa<=30 0 1 S
+R P 2020 o - O 24 1 0 -
+R P 2021 o - O 29 1 0 -
+R P 2022 o - Mar 27 0 1 S
+R P 2022 2035 - O Sa<=30 2 0 -
+R P 2023 o - Ap 29 2 1 S
+R P 2024 o - Ap 20 2 1 S
+R P 2025 o - Ap 12 2 1 S
+R P 2026 2054 - Mar Sa<=30 2 1 S
+R P 2036 o - O 18 2 0 -
+R P 2037 o - O 10 2 0 -
+R P 2038 o - S 25 2 0 -
+R P 2039 o - S 17 2 0 -
+R P 2040 o - S 1 2 0 -
+R P 2040 o - O 20 2 1 S
+R P 2040 2067 - O Sa<=30 2 0 -
+R P 2041 o - Au 24 2 0 -
+R P 2041 o - O 5 2 1 S
+R P 2042 o - Au 16 2 0 -
+R P 2042 o - S 27 2 1 S
+R P 2043 o - Au 1 2 0 -
+R P 2043 o - S 19 2 1 S
+R P 2044 o - Jul 23 2 0 -
+R P 2044 o - S 3 2 1 S
+R P 2045 o - Jul 15 2 0 -
+R P 2045 o - Au 26 2 1 S
+R P 2046 o - Jun 30 2 0 -
+R P 2046 o - Au 18 2 1 S
+R P 2047 o - Jun 22 2 0 -
+R P 2047 o - Au 3 2 1 S
+R P 2048 o - Jun 6 2 0 -
+R P 2048 o - Jul 25 2 1 S
+R P 2049 o - May 29 2 0 -
+R P 2049 o - Jul 10 2 1 S
+R P 2050 o - May 21 2 0 -
+R P 2050 o - Jul 2 2 1 S
+R P 2051 o - May 6 2 0 -
+R P 2051 o - Jun 24 2 1 S
+R P 2052 o - Ap 27 2 0 -
+R P 2052 o - Jun 8 2 1 S
+R P 2053 o - Ap 12 2 0 -
+R P 2053 o - May 31 2 1 S
+R P 2054 o - Ap 4 2 0 -
+R P 2054 o - May 23 2 1 S
+R P 2055 o - May 8 2 1 S
+R P 2056 o - Ap 29 2 1 S
+R P 2057 o - Ap 14 2 1 S
+R P 2058 o - Ap 6 2 1 S
+R P 2059 ma - Mar Sa<=30 2 1 S
+R P 2068 o - O 20 2 0 -
+R P 2069 o - O 12 2 0 -
+R P 2070 o - O 4 2 0 -
+R P 2071 o - S 19 2 0 -
+R P 2072 o - S 10 2 0 -
+R P 2072 o - O 22 2 1 S
+R P 2072 ma - O Sa<=30 2 0 -
+R P 2073 o - S 2 2 0 -
+R P 2073 o - O 14 2 1 S
+R P 2074 o - Au 18 2 0 -
+R P 2074 o - O 6 2 1 S
+R P 2075 o - Au 10 2 0 -
+R P 2075 o - S 21 2 1 S
+R P 2076 o - Jul 25 2 0 -
+R P 2076 o - S 12 2 1 S
+R P 2077 o - Jul 17 2 0 -
+R P 2077 o - S 4 2 1 S
+R P 2078 o - Jul 9 2 0 -
+R P 2078 o - Au 20 2 1 S
+R P 2079 o - Jun 24 2 0 -
+R P 2079 o - Au 12 2 1 S
+R P 2080 o - Jun 15 2 0 -
+R P 2080 o - Jul 27 2 1 S
+R P 2081 o - Jun 7 2 0 -
+R P 2081 o - Jul 19 2 1 S
+R P 2082 o - May 23 2 0 -
+R P 2082 o - Jul 11 2 1 S
+R P 2083 o - May 15 2 0 -
+R P 2083 o - Jun 26 2 1 S
+R P 2084 o - Ap 29 2 0 -
+R P 2084 o - Jun 17 2 1 S
+R P 2085 o - Ap 21 2 0 -
+R P 2085 o - Jun 9 2 1 S
+R P 2086 o - Ap 13 2 0 -
+R P 2086 o - May 25 2 1 S
+R PH 1936 o - O 31 24 1 D
+R PH 1937 o - Ja 15 24 0 S
+R PH 1941 o - D 15 24 1 D
+R PH 1945 o - N 30 24 0 S
+R PH 1954 o - Ap 11 24 1 D
+R PH 1954 o - Jun 4 24 0 S
+R PH 1977 o - Mar 27 24 1 D
+R PH 1977 o - S 21 24 0 S
+R PH 1990 o - May 21 0 1 D
+R PH 1990 o - Jul 28 24 0 S
+R S 1920 1923 - Ap Su>=15 2 1 S
+R S 1920 1923 - O Su>=1 2 0 -
+R S 1962 o - Ap 29 2 1 S
+R S 1962 o - O 1 2 0 -
+R S 1963 1965 - May 1 2 1 S
+R S 1963 o - S 30 2 0 -
+R S 1964 o - O 1 2 0 -
+R S 1965 o - S 30 2 0 -
+R S 1966 o - Ap 24 2 1 S
+R S 1966 1976 - O 1 2 0 -
+R S 1967 1978 - May 1 2 1 S
+R S 1977 1978 - S 1 2 0 -
+R S 1983 1984 - Ap 9 2 1 S
+R S 1983 1984 - O 1 2 0 -
+R S 1986 o - F 16 2 1 S
+R S 1986 o - O 9 2 0 -
+R S 1987 o - Mar 1 2 1 S
+R S 1987 1988 - O 31 2 0 -
+R S 1988 o - Mar 15 2 1 S
+R S 1989 o - Mar 31 2 1 S
+R S 1989 o - O 1 2 0 -
+R S 1990 o - Ap 1 2 1 S
+R S 1990 o - S 30 2 0 -
+R S 1991 o - Ap 1 0 1 S
+R S 1991 1992 - O 1 0 0 -
+R S 1992 o - Ap 8 0 1 S
+R S 1993 o - Mar 26 0 1 S
+R S 1993 o - S 25 0 0 -
+R S 1994 1996 - Ap 1 0 1 S
+R S 1994 2005 - O 1 0 0 -
+R S 1997 1998 - Mar lastM 0 1 S
+R S 1999 2006 - Ap 1 0 1 S
+R S 2006 o - S 22 0 0 -
+R S 2007 o - Mar lastF 0 1 S
+R S 2007 o - N F>=1 0 0 -
+R S 2008 o - Ap F>=1 0 1 S
+R S 2008 o - N 1 0 0 -
+R S 2009 o - Mar lastF 0 1 S
+R S 2010 2011 - Ap F>=1 0 1 S
+R S 2012 2022 - Mar lastF 0 1 S
+R S 2009 2022 - O lastF 0 0 -
+R AU 1917 o - Ja 1 2s 1 D
+R AU 1917 o - Mar lastSu 2s 0 S
+R AU 1942 o - Ja 1 2s 1 D
+R AU 1942 o - Mar lastSu 2s 0 S
+R AU 1942 o - S 27 2s 1 D
+R AU 1943 1944 - Mar lastSu 2s 0 S
+R AU 1943 o - O 3 2s 1 D
+R AW 1974 o - O lastSu 2s 1 D
+R AW 1975 o - Mar Su>=1 2s 0 S
+R AW 1983 o - O lastSu 2s 1 D
+R AW 1984 o - Mar Su>=1 2s 0 S
+R AW 1991 o - N 17 2s 1 D
+R AW 1992 o - Mar Su>=1 2s 0 S
+R AW 2006 o - D 3 2s 1 D
+R AW 2007 2009 - Mar lastSu 2s 0 S
+R AW 2007 2008 - O lastSu 2s 1 D
+R AQ 1971 o - O lastSu 2s 1 D
+R AQ 1972 o - F lastSu 2s 0 S
+R AQ 1989 1991 - O lastSu 2s 1 D
+R AQ 1990 1992 - Mar Su>=1 2s 0 S
+R Ho 1992 1993 - O lastSu 2s 1 D
+R Ho 1993 1994 - Mar Su>=1 2s 0 S
+R AS 1971 1985 - O lastSu 2s 1 D
+R AS 1986 o - O 19 2s 1 D
+R AS 1987 2007 - O lastSu 2s 1 D
+R AS 1972 o - F 27 2s 0 S
+R AS 1973 1985 - Mar Su>=1 2s 0 S
+R AS 1986 1990 - Mar Su>=15 2s 0 S
+R AS 1991 o - Mar 3 2s 0 S
+R AS 1992 o - Mar 22 2s 0 S
+R AS 1993 o - Mar 7 2s 0 S
+R AS 1994 o - Mar 20 2s 0 S
+R AS 1995 2005 - Mar lastSu 2s 0 S
+R AS 2006 o - Ap 2 2s 0 S
+R AS 2007 o - Mar lastSu 2s 0 S
+R AS 2008 ma - Ap Su>=1 2s 0 S
+R AS 2008 ma - O Su>=1 2s 1 D
+R AT 1916 o - O Su>=1 2s 1 D
+R AT 1917 o - Mar lastSu 2s 0 S
+R AT 1917 1918 - O Su>=22 2s 1 D
+R AT 1918 1919 - Mar Su>=1 2s 0 S
+R AT 1967 o - O Su>=1 2s 1 D
+R AT 1968 o - Mar Su>=29 2s 0 S
+R AT 1968 1985 - O lastSu 2s 1 D
+R AT 1969 1971 - Mar Su>=8 2s 0 S
+R AT 1972 o - F lastSu 2s 0 S
+R AT 1973 1981 - Mar Su>=1 2s 0 S
+R AT 1982 1983 - Mar lastSu 2s 0 S
+R AT 1984 1986 - Mar Su>=1 2s 0 S
+R AT 1986 o - O Su>=15 2s 1 D
+R AT 1987 1990 - Mar Su>=15 2s 0 S
+R AT 1987 o - O Su>=22 2s 1 D
+R AT 1988 1990 - O lastSu 2s 1 D
+R AT 1991 1999 - O Su>=1 2s 1 D
+R AT 1991 2005 - Mar lastSu 2s 0 S
+R AT 2000 o - Au lastSu 2s 1 D
+R AT 2001 ma - O Su>=1 2s 1 D
+R AT 2006 o - Ap Su>=1 2s 0 S
+R AT 2007 o - Mar lastSu 2s 0 S
+R AT 2008 ma - Ap Su>=1 2s 0 S
+R AV 1971 1985 - O lastSu 2s 1 D
+R AV 1972 o - F lastSu 2s 0 S
+R AV 1973 1985 - Mar Su>=1 2s 0 S
+R AV 1986 1990 - Mar Su>=15 2s 0 S
+R AV 1986 1987 - O Su>=15 2s 1 D
+R AV 1988 1999 - O lastSu 2s 1 D
+R AV 1991 1994 - Mar Su>=1 2s 0 S
+R AV 1995 2005 - Mar lastSu 2s 0 S
+R AV 2000 o - Au lastSu 2s 1 D
+R AV 2001 2007 - O lastSu 2s 1 D
+R AV 2006 o - Ap Su>=1 2s 0 S
+R AV 2007 o - Mar lastSu 2s 0 S
+R AV 2008 ma - Ap Su>=1 2s 0 S
+R AV 2008 ma - O Su>=1 2s 1 D
+R AN 1971 1985 - O lastSu 2s 1 D
+R AN 1972 o - F 27 2s 0 S
+R AN 1973 1981 - Mar Su>=1 2s 0 S
+R AN 1982 o - Ap Su>=1 2s 0 S
+R AN 1983 1985 - Mar Su>=1 2s 0 S
+R AN 1986 1989 - Mar Su>=15 2s 0 S
+R AN 1986 o - O 19 2s 1 D
+R AN 1987 1999 - O lastSu 2s 1 D
+R AN 1990 1995 - Mar Su>=1 2s 0 S
+R AN 1996 2005 - Mar lastSu 2s 0 S
+R AN 2000 o - Au lastSu 2s 1 D
+R AN 2001 2007 - O lastSu 2s 1 D
+R AN 2006 o - Ap Su>=1 2s 0 S
+R AN 2007 o - Mar lastSu 2s 0 S
+R AN 2008 ma - Ap Su>=1 2s 0 S
+R AN 2008 ma - O Su>=1 2s 1 D
+R LH 1981 1984 - O lastSu 2 1 -
+R LH 1982 1985 - Mar Su>=1 2 0 -
+R LH 1985 o - O lastSu 2 0:30 -
+R LH 1986 1989 - Mar Su>=15 2 0 -
+R LH 1986 o - O 19 2 0:30 -
+R LH 1987 1999 - O lastSu 2 0:30 -
+R LH 1990 1995 - Mar Su>=1 2 0 -
+R LH 1996 2005 - Mar lastSu 2 0 -
+R LH 2000 o - Au lastSu 2 0:30 -
+R LH 2001 2007 - O lastSu 2 0:30 -
+R LH 2006 o - Ap Su>=1 2 0 -
+R LH 2007 o - Mar lastSu 2 0 -
+R LH 2008 ma - Ap Su>=1 2 0 -
+R LH 2008 ma - O Su>=1 2 0:30 -
+R FJ 1998 1999 - N Su>=1 2 1 -
+R FJ 1999 2000 - F lastSu 3 0 -
+R FJ 2009 o - N 29 2 1 -
+R FJ 2010 o - Mar lastSu 3 0 -
+R FJ 2010 2013 - O Su>=21 2 1 -
+R FJ 2011 o - Mar Su>=1 3 0 -
+R FJ 2012 2013 - Ja Su>=18 3 0 -
+R FJ 2014 o - Ja Su>=18 2 0 -
+R FJ 2014 2018 - N Su>=1 2 1 -
+R FJ 2015 2021 - Ja Su>=12 3 0 -
+R FJ 2019 o - N Su>=8 2 1 -
+R FJ 2020 o - D 20 2 1 -
+R Gu 1959 o - Jun 27 2 1 D
+R Gu 1961 o - Ja 29 2 0 S
+R Gu 1967 o - S 1 2 1 D
+R Gu 1969 o - Ja 26 0:1 0 S
+R Gu 1969 o - Jun 22 2 1 D
+R Gu 1969 o - Au 31 2 0 S
+R Gu 1970 1971 - Ap lastSu 2 1 D
+R Gu 1970 1971 - S Su>=1 2 0 S
+R Gu 1973 o - D 16 2 1 D
+R Gu 1974 o - F 24 2 0 S
+R Gu 1976 o - May 26 2 1 D
+R Gu 1976 o - Au 22 2:1 0 S
+R Gu 1977 o - Ap 24 2 1 D
+R Gu 1977 o - Au 28 2 0 S
+R NC 1977 1978 - D Su>=1 0 1 -
+R NC 1978 1979 - F 27 0 0 -
+R NC 1996 o - D 1 2s 1 -
+R NC 1997 o - Mar 2 2s 0 -
+R NZ 1927 o - N 6 2 1 S
+R NZ 1928 o - Mar 4 2 0 M
+R NZ 1928 1933 - O Su>=8 2 0:30 S
+R NZ 1929 1933 - Mar Su>=15 2 0 M
+R NZ 1934 1940 - Ap lastSu 2 0 M
+R NZ 1934 1940 - S lastSu 2 0:30 S
+R NZ 1946 o - Ja 1 0 0 S
+R NZ 1974 o - N Su>=1 2s 1 D
+R k 1974 o - N Su>=1 2:45s 1 -
+R NZ 1975 o - F lastSu 2s 0 S
+R k 1975 o - F lastSu 2:45s 0 -
+R NZ 1975 1988 - O lastSu 2s 1 D
+R k 1975 1988 - O lastSu 2:45s 1 -
+R NZ 1976 1989 - Mar Su>=1 2s 0 S
+R k 1976 1989 - Mar Su>=1 2:45s 0 -
+R NZ 1989 o - O Su>=8 2s 1 D
+R k 1989 o - O Su>=8 2:45s 1 -
+R NZ 1990 2006 - O Su>=1 2s 1 D
+R k 1990 2006 - O Su>=1 2:45s 1 -
+R NZ 1990 2007 - Mar Su>=15 2s 0 S
+R k 1990 2007 - Mar Su>=15 2:45s 0 -
+R NZ 2007 ma - S lastSu 2s 1 D
+R k 2007 ma - S lastSu 2:45s 1 -
+R NZ 2008 ma - Ap Su>=1 2s 0 S
+R k 2008 ma - Ap Su>=1 2:45s 0 -
+R CK 1978 o - N 12 0 0:30 -
+R CK 1979 1991 - Mar Su>=1 0 0 -
+R CK 1979 1990 - O lastSu 0 0:30 -
+R WS 2010 o - S lastSu 0 1 -
+R WS 2011 o - Ap Sa>=1 4 0 -
+R WS 2011 o - S lastSa 3 1 -
+R WS 2012 2021 - Ap Su>=1 4 0 -
+R WS 2012 2020 - S lastSu 3 1 -
+R TO 1999 o - O 7 2s 1 -
+R TO 2000 o - Mar 19 2s 0 -
+R TO 2000 2001 - N Su>=1 2 1 -
+R TO 2001 2002 - Ja lastSu 2 0 -
+R TO 2016 o - N Su>=1 2 1 -
+R TO 2017 o - Ja Su>=15 3 0 -
+R VU 1973 o - D 22 12u 1 -
+R VU 1974 o - Mar 30 12u 0 -
+R VU 1983 1991 - S Sa>=22 24 1 -
+R VU 1984 1991 - Mar Sa>=22 24 0 -
+R VU 1992 1993 - Ja Sa>=22 24 0 -
+R VU 1992 o - O Sa>=22 24 1 -
+R G 1916 o - May 21 2s 1 BST
+R G 1916 o - O 1 2s 0 GMT
+R G 1917 o - Ap 8 2s 1 BST
+R G 1917 o - S 17 2s 0 GMT
+R G 1918 o - Mar 24 2s 1 BST
+R G 1918 o - S 30 2s 0 GMT
+R G 1919 o - Mar 30 2s 1 BST
+R G 1919 o - S 29 2s 0 GMT
+R G 1920 o - Mar 28 2s 1 BST
+R G 1920 o - O 25 2s 0 GMT
+R G 1921 o - Ap 3 2s 1 BST
+R G 1921 o - O 3 2s 0 GMT
+R G 1922 o - Mar 26 2s 1 BST
+R G 1922 o - O 8 2s 0 GMT
+R G 1923 o - Ap Su>=16 2s 1 BST
+R G 1923 1924 - S Su>=16 2s 0 GMT
+R G 1924 o - Ap Su>=9 2s 1 BST
+R G 1925 1926 - Ap Su>=16 2s 1 BST
+R G 1925 1938 - O Su>=2 2s 0 GMT
+R G 1927 o - Ap Su>=9 2s 1 BST
+R G 1928 1929 - Ap Su>=16 2s 1 BST
+R G 1930 o - Ap Su>=9 2s 1 BST
+R G 1931 1932 - Ap Su>=16 2s 1 BST
+R G 1933 o - Ap Su>=9 2s 1 BST
+R G 1934 o - Ap Su>=16 2s 1 BST
+R G 1935 o - Ap Su>=9 2s 1 BST
+R G 1936 1937 - Ap Su>=16 2s 1 BST
+R G 1938 o - Ap Su>=9 2s 1 BST
+R G 1939 o - Ap Su>=16 2s 1 BST
+R G 1939 o - N Su>=16 2s 0 GMT
+R G 1940 o - F Su>=23 2s 1 BST
+R G 1941 o - May Su>=2 1s 2 BDST
+R G 1941 1943 - Au Su>=9 1s 1 BST
+R G 1942 1944 - Ap Su>=2 1s 2 BDST
+R G 1944 o - S Su>=16 1s 1 BST
+R G 1945 o - Ap M>=2 1s 2 BDST
+R G 1945 o - Jul Su>=9 1s 1 BST
+R G 1945 1946 - O Su>=2 2s 0 GMT
+R G 1946 o - Ap Su>=9 2s 1 BST
+R G 1947 o - Mar 16 2s 1 BST
+R G 1947 o - Ap 13 1s 2 BDST
+R G 1947 o - Au 10 1s 1 BST
+R G 1947 o - N 2 2s 0 GMT
+R G 1948 o - Mar 14 2s 1 BST
+R G 1948 o - O 31 2s 0 GMT
+R G 1949 o - Ap 3 2s 1 BST
+R G 1949 o - O 30 2s 0 GMT
+R G 1950 1952 - Ap Su>=14 2s 1 BST
+R G 1950 1952 - O Su>=21 2s 0 GMT
+R G 1953 o - Ap Su>=16 2s 1 BST
+R G 1953 1960 - O Su>=2 2s 0 GMT
+R G 1954 o - Ap Su>=9 2s 1 BST
+R G 1955 1956 - Ap Su>=16 2s 1 BST
+R G 1957 o - Ap Su>=9 2s 1 BST
+R G 1958 1959 - Ap Su>=16 2s 1 BST
+R G 1960 o - Ap Su>=9 2s 1 BST
+R G 1961 1963 - Mar lastSu 2s 1 BST
+R G 1961 1968 - O Su>=23 2s 0 GMT
+R G 1964 1967 - Mar Su>=19 2s 1 BST
+R G 1968 o - F 18 2s 1 BST
+R G 1972 1980 - Mar Su>=16 2s 1 BST
+R G 1972 1980 - O Su>=23 2s 0 GMT
+R G 1981 1995 - Mar lastSu 1u 1 BST
+R G 1981 1989 - O Su>=23 1u 0 GMT
+R G 1990 1995 - O Su>=22 1u 0 GMT
+R IE 1971 o - O 31 2u -1 -
+R IE 1972 1980 - Mar Su>=16 2u 0 -
+R IE 1972 1980 - O Su>=23 2u -1 -
+R IE 1981 ma - Mar lastSu 1u 0 -
+R IE 1981 1989 - O Su>=23 1u -1 -
+R IE 1990 1995 - O Su>=22 1u -1 -
+R IE 1996 ma - O lastSu 1u -1 -
+R E 1977 1980 - Ap Su>=1 1u 1 S
+R E 1977 o - S lastSu 1u 0 -
+R E 1978 o - O 1 1u 0 -
+R E 1979 1995 - S lastSu 1u 0 -
+R E 1981 ma - Mar lastSu 1u 1 S
+R E 1996 ma - O lastSu 1u 0 -
+R W- 1977 1980 - Ap Su>=1 1s 1 S
+R W- 1977 o - S lastSu 1s 0 -
+R W- 1978 o - O 1 1s 0 -
+R W- 1979 1995 - S lastSu 1s 0 -
+R W- 1981 ma - Mar lastSu 1s 1 S
+R W- 1996 ma - O lastSu 1s 0 -
+R c 1916 o - Ap 30 23 1 S
+R c 1916 o - O 1 1 0 -
+R c 1917 1918 - Ap M>=15 2s 1 S
+R c 1917 1918 - S M>=15 2s 0 -
+R c 1940 o - Ap 1 2s 1 S
+R c 1942 o - N 2 2s 0 -
+R c 1943 o - Mar 29 2s 1 S
+R c 1943 o - O 4 2s 0 -
+R c 1944 1945 - Ap M>=1 2s 1 S
+R c 1944 o - O 2 2s 0 -
+R c 1945 o - S 16 2s 0 -
+R c 1977 1980 - Ap Su>=1 2s 1 S
+R c 1977 o - S lastSu 2s 0 -
+R c 1978 o - O 1 2s 0 -
+R c 1979 1995 - S lastSu 2s 0 -
+R c 1981 ma - Mar lastSu 2s 1 S
+R c 1996 ma - O lastSu 2s 0 -
+R e 1977 1980 - Ap Su>=1 0 1 S
+R e 1977 o - S lastSu 0 0 -
+R e 1978 o - O 1 0 0 -
+R e 1979 1995 - S lastSu 0 0 -
+R e 1981 ma - Mar lastSu 0 1 S
+R e 1996 ma - O lastSu 0 0 -
+R R 1917 o - Jul 1 23 1 MST
+R R 1917 o - D 28 0 0 MMT
+R R 1918 o - May 31 22 2 MDST
+R R 1918 o - S 16 1 1 MST
+R R 1919 o - May 31 23 2 MDST
+R R 1919 o - Jul 1 0u 1 MSD
+R R 1919 o - Au 16 0 0 MSK
+R R 1921 o - F 14 23 1 MSD
+R R 1921 o - Mar 20 23 2 +05
+R R 1921 o - S 1 0 1 MSD
+R R 1921 o - O 1 0 0 -
+R R 1981 1984 - Ap 1 0 1 S
+R R 1981 1983 - O 1 0 0 -
+R R 1984 1995 - S lastSu 2s 0 -
+R R 1985 2010 - Mar lastSu 2s 1 S
+R R 1996 2010 - O lastSu 2s 0 -
+R q 1940 o - Jun 16 0 1 S
+R q 1942 o - N 2 3 0 -
+R q 1943 o - Mar 29 2 1 S
+R q 1943 o - Ap 10 3 0 -
+R q 1974 o - May 4 0 1 S
+R q 1974 o - O 2 0 0 -
+R q 1975 o - May 1 0 1 S
+R q 1975 o - O 2 0 0 -
+R q 1976 o - May 2 0 1 S
+R q 1976 o - O 3 0 0 -
+R q 1977 o - May 8 0 1 S
+R q 1977 o - O 2 0 0 -
+R q 1978 o - May 6 0 1 S
+R q 1978 o - O 1 0 0 -
+R q 1979 o - May 5 0 1 S
+R q 1979 o - S 30 0 0 -
+R q 1980 o - May 3 0 1 S
+R q 1980 o - O 4 0 0 -
+R q 1981 o - Ap 26 0 1 S
+R q 1981 o - S 27 0 0 -
+R q 1982 o - May 2 0 1 S
+R q 1982 o - O 3 0 0 -
+R q 1983 o - Ap 18 0 1 S
+R q 1983 o - O 1 0 0 -
+R q 1984 o - Ap 1 0 1 S
+R a 1920 o - Ap 5 2s 1 S
+R a 1920 o - S 13 2s 0 -
+R a 1946 o - Ap 14 2s 1 S
+R a 1946 o - O 7 2s 0 -
+R a 1947 1948 - O Su>=1 2s 0 -
+R a 1947 o - Ap 6 2s 1 S
+R a 1948 o - Ap 18 2s 1 S
+R a 1980 o - Ap 6 0 1 S
+R a 1980 o - S 28 0 0 -
+R b 1918 o - Mar 9 0s 1 S
+R b 1918 1919 - O Sa>=1 23s 0 -
+R b 1919 o - Mar 1 23s 1 S
+R b 1920 o - F 14 23s 1 S
+R b 1920 o - O 23 23s 0 -
+R b 1921 o - Mar 14 23s 1 S
+R b 1921 o - O 25 23s 0 -
+R b 1922 o - Mar 25 23s 1 S
+R b 1922 1927 - O Sa>=1 23s 0 -
+R b 1923 o - Ap 21 23s 1 S
+R b 1924 o - Mar 29 23s 1 S
+R b 1925 o - Ap 4 23s 1 S
+R b 1926 o - Ap 17 23s 1 S
+R b 1927 o - Ap 9 23s 1 S
+R b 1928 o - Ap 14 23s 1 S
+R b 1928 1938 - O Su>=2 2s 0 -
+R b 1929 o - Ap 21 2s 1 S
+R b 1930 o - Ap 13 2s 1 S
+R b 1931 o - Ap 19 2s 1 S
+R b 1932 o - Ap 3 2s 1 S
+R b 1933 o - Mar 26 2s 1 S
+R b 1934 o - Ap 8 2s 1 S
+R b 1935 o - Mar 31 2s 1 S
+R b 1936 o - Ap 19 2s 1 S
+R b 1937 o - Ap 4 2s 1 S
+R b 1938 o - Mar 27 2s 1 S
+R b 1939 o - Ap 16 2s 1 S
+R b 1939 o - N 19 2s 0 -
+R b 1940 o - F 25 2s 1 S
+R b 1944 o - S 17 2s 0 -
+R b 1945 o - Ap 2 2s 1 S
+R b 1945 o - S 16 2s 0 -
+R b 1946 o - May 19 2s 1 S
+R b 1946 o - O 7 2s 0 -
+R BG 1979 o - Mar 31 23 1 S
+R BG 1979 o - O 1 1 0 -
+R BG 1980 1982 - Ap Sa>=1 23 1 S
+R BG 1980 o - S 29 1 0 -
+R BG 1981 o - S 27 2 0 -
+R CZ 1945 o - Ap M>=1 2s 1 S
+R CZ 1945 o - O 1 2s 0 -
+R CZ 1946 o - May 6 2s 1 S
+R CZ 1946 1949 - O Su>=1 2s 0 -
+R CZ 1947 1948 - Ap Su>=15 2s 1 S
+R CZ 1949 o - Ap 9 2s 1 S
+R Th 1991 1992 - Mar lastSu 2 1 D
+R Th 1991 1992 - S lastSu 2 0 S
+R Th 1993 2006 - Ap Su>=1 2 1 D
+R Th 1993 2006 - O lastSu 2 0 S
+R Th 2007 ma - Mar Su>=8 2 1 D
+R Th 2007 ma - N Su>=1 2 0 S
+R FI 1942 o - Ap 2 24 1 S
+R FI 1942 o - O 4 1 0 -
+R FI 1981 1982 - Mar lastSu 2 1 S
+R FI 1981 1982 - S lastSu 3 0 -
+R F 1916 o - Jun 14 23s 1 S
+R F 1916 1919 - O Su>=1 23s 0 -
+R F 1917 o - Mar 24 23s 1 S
+R F 1918 o - Mar 9 23s 1 S
+R F 1919 o - Mar 1 23s 1 S
+R F 1920 o - F 14 23s 1 S
+R F 1920 o - O 23 23s 0 -
+R F 1921 o - Mar 14 23s 1 S
+R F 1921 o - O 25 23s 0 -
+R F 1922 o - Mar 25 23s 1 S
+R F 1922 1938 - O Sa>=1 23s 0 -
+R F 1923 o - May 26 23s 1 S
+R F 1924 o - Mar 29 23s 1 S
+R F 1925 o - Ap 4 23s 1 S
+R F 1926 o - Ap 17 23s 1 S
+R F 1927 o - Ap 9 23s 1 S
+R F 1928 o - Ap 14 23s 1 S
+R F 1929 o - Ap 20 23s 1 S
+R F 1930 o - Ap 12 23s 1 S
+R F 1931 o - Ap 18 23s 1 S
+R F 1932 o - Ap 2 23s 1 S
+R F 1933 o - Mar 25 23s 1 S
+R F 1934 o - Ap 7 23s 1 S
+R F 1935 o - Mar 30 23s 1 S
+R F 1936 o - Ap 18 23s 1 S
+R F 1937 o - Ap 3 23s 1 S
+R F 1938 o - Mar 26 23s 1 S
+R F 1939 o - Ap 15 23s 1 S
+R F 1939 o - N 18 23s 0 -
+R F 1940 o - F 25 2 1 S
+R F 1941 o - May 5 0 2 M
+R F 1941 o - O 6 0 1 S
+R F 1942 o - Mar 9 0 2 M
+R F 1942 o - N 2 3 1 S
+R F 1943 o - Mar 29 2 2 M
+R F 1943 o - O 4 3 1 S
+R F 1944 o - Ap 3 2 2 M
+R F 1944 o - O 8 1 1 S
+R F 1945 o - Ap 2 2 2 M
+R F 1945 o - S 16 3 0 -
+R F 1976 o - Mar 28 1 1 S
+R F 1976 o - S 26 1 0 -
+R DE 1946 o - Ap 14 2s 1 S
+R DE 1946 o - O 7 2s 0 -
+R DE 1947 1949 - O Su>=1 2s 0 -
+R DE 1947 o - Ap 6 3s 1 S
+R DE 1947 o - May 11 2s 2 M
+R DE 1947 o - Jun 29 3 1 S
+R DE 1948 o - Ap 18 2s 1 S
+R DE 1949 o - Ap 10 2s 1 S
+R So 1945 o - May 24 2 2 M
+R So 1945 o - S 24 3 1 S
+R So 1945 o - N 18 2s 0 -
+R g 1932 o - Jul 7 0 1 S
+R g 1932 o - S 1 0 0 -
+R g 1941 o - Ap 7 0 1 S
+R g 1942 o - N 2 3 0 -
+R g 1943 o - Mar 30 0 1 S
+R g 1943 o - O 4 0 0 -
+R g 1952 o - Jul 1 0 1 S
+R g 1952 o - N 2 0 0 -
+R g 1975 o - Ap 12 0s 1 S
+R g 1975 o - N 26 0s 0 -
+R g 1976 o - Ap 11 2s 1 S
+R g 1976 o - O 10 2s 0 -
+R g 1977 1978 - Ap Su>=1 2s 1 S
+R g 1977 o - S 26 2s 0 -
+R g 1978 o - S 24 4 0 -
+R g 1979 o - Ap 1 9 1 S
+R g 1979 o - S 29 2 0 -
+R g 1980 o - Ap 1 0 1 S
+R g 1980 o - S 28 0 0 -
+R h 1918 1919 - Ap 15 2 1 S
+R h 1918 1920 - S M>=15 3 0 -
+R h 1920 o - Ap 5 2 1 S
+R h 1945 o - May 1 23 1 S
+R h 1945 o - N 1 1 0 -
+R h 1946 o - Mar 31 2s 1 S
+R h 1946 o - O 7 2 0 -
+R h 1947 1949 - Ap Su>=4 2s 1 S
+R h 1947 1949 - O Su>=1 2s 0 -
+R h 1954 o - May 23 0 1 S
+R h 1954 o - O 3 0 0 -
+R h 1955 o - May 22 2 1 S
+R h 1955 o - O 2 3 0 -
+R h 1956 1957 - Jun Su>=1 2 1 S
+R h 1956 1957 - S lastSu 3 0 -
+R h 1980 o - Ap 6 0 1 S
+R h 1980 o - S 28 1 0 -
+R h 1981 1983 - Mar lastSu 0 1 S
+R h 1981 1983 - S lastSu 1 0 -
+R I 1916 o - Jun 3 24 1 S
+R I 1916 1917 - S 30 24 0 -
+R I 1917 o - Mar 31 24 1 S
+R I 1918 o - Mar 9 24 1 S
+R I 1918 o - O 6 24 0 -
+R I 1919 o - Mar 1 24 1 S
+R I 1919 o - O 4 24 0 -
+R I 1920 o - Mar 20 24 1 S
+R I 1920 o - S 18 24 0 -
+R I 1940 o - Jun 14 24 1 S
+R I 1942 o - N 2 2s 0 -
+R I 1943 o - Mar 29 2s 1 S
+R I 1943 o - O 4 2s 0 -
+R I 1944 o - Ap 2 2s 1 S
+R I 1944 o - S 17 2s 0 -
+R I 1945 o - Ap 2 2 1 S
+R I 1945 o - S 15 1 0 -
+R I 1946 o - Mar 17 2s 1 S
+R I 1946 o - O 6 2s 0 -
+R I 1947 o - Mar 16 0s 1 S
+R I 1947 o - O 5 0s 0 -
+R I 1948 o - F 29 2s 1 S
+R I 1948 o - O 3 2s 0 -
+R I 1966 1968 - May Su>=22 0s 1 S
+R I 1966 o - S 24 24 0 -
+R I 1967 1969 - S Su>=22 0s 0 -
+R I 1969 o - Jun 1 0s 1 S
+R I 1970 o - May 31 0s 1 S
+R I 1970 o - S lastSu 0s 0 -
+R I 1971 1972 - May Su>=22 0s 1 S
+R I 1971 o - S lastSu 0s 0 -
+R I 1972 o - O 1 0s 0 -
+R I 1973 o - Jun 3 0s 1 S
+R I 1973 1974 - S lastSu 0s 0 -
+R I 1974 o - May 26 0s 1 S
+R I 1975 o - Jun 1 0s 1 S
+R I 1975 1977 - S lastSu 0s 0 -
+R I 1976 o - May 30 0s 1 S
+R I 1977 1979 - May Su>=22 0s 1 S
+R I 1978 o - O 1 0s 0 -
+R I 1979 o - S 30 0s 0 -
+R LV 1989 1996 - Mar lastSu 2s 1 S
+R LV 1989 1996 - S lastSu 2s 0 -
+R MT 1973 o - Mar 31 0s 1 S
+R MT 1973 o - S 29 0s 0 -
+R MT 1974 o - Ap 21 0s 1 S
+R MT 1974 o - S 16 0s 0 -
+R MT 1975 1979 - Ap Su>=15 2 1 S
+R MT 1975 1980 - S Su>=15 2 0 -
+R MT 1980 o - Mar 31 2 1 S
+R MD 1997 ma - Mar lastSu 2 1 S
+R MD 1997 ma - O lastSu 3 0 -
+R O 1918 1919 - S 16 2s 0 -
+R O 1919 o - Ap 15 2s 1 S
+R O 1944 o - Ap 3 2s 1 S
+R O 1944 o - O 4 2 0 -
+R O 1945 o - Ap 29 0 1 S
+R O 1945 o - N 1 0 0 -
+R O 1946 o - Ap 14 0s 1 S
+R O 1946 o - O 7 2s 0 -
+R O 1947 o - May 4 2s 1 S
+R O 1947 1949 - O Su>=1 2s 0 -
+R O 1948 o - Ap 18 2s 1 S
+R O 1949 o - Ap 10 2s 1 S
+R O 1957 o - Jun 2 1s 1 S
+R O 1957 1958 - S lastSu 1s 0 -
+R O 1958 o - Mar 30 1s 1 S
+R O 1959 o - May 31 1s 1 S
+R O 1959 1961 - O Su>=1 1s 0 -
+R O 1960 o - Ap 3 1s 1 S
+R O 1961 1964 - May lastSu 1s 1 S
+R O 1962 1964 - S lastSu 1s 0 -
+R p 1916 o - Jun 17 23 1 S
+R p 1916 o - N 1 1 0 -
+R p 1917 1921 - Mar 1 0 1 S
+R p 1917 1921 - O 14 24 0 -
+R p 1924 o - Ap 16 23s 1 S
+R p 1924 o - O 4 23s 0 -
+R p 1926 o - Ap 17 23s 1 S
+R p 1926 1929 - O Sa>=1 23s 0 -
+R p 1927 o - Ap 9 23s 1 S
+R p 1928 o - Ap 14 23s 1 S
+R p 1929 o - Ap 20 23s 1 S
+R p 1931 o - Ap 18 23s 1 S
+R p 1931 1932 - O Sa>=1 23s 0 -
+R p 1932 o - Ap 2 23s 1 S
+R p 1934 o - Ap 7 23s 1 S
+R p 1934 1938 - O Sa>=1 23s 0 -
+R p 1935 o - Mar 30 23s 1 S
+R p 1936 o - Ap 18 23s 1 S
+R p 1937 o - Ap 3 23s 1 S
+R p 1938 o - Mar 26 23s 1 S
+R p 1939 o - Ap 15 23s 1 S
+R p 1939 o - N 18 23s 0 -
+R p 1940 o - F 24 23s 1 S
+R p 1940 o - O 7 23s 0 -
+R p 1941 o - Ap 5 23s 1 S
+R p 1941 o - O 5 23s 0 -
+R p 1942 1945 - Mar Sa>=8 23s 1 S
+R p 1942 o - Ap 25 22s 2 M
+R p 1942 o - Au 15 22s 1 S
+R p 1942 1945 - O Sa>=24 23s 0 -
+R p 1943 o - Ap 17 22s 2 M
+R p 1943 1945 - Au Sa>=25 22s 1 S
+R p 1944 1945 - Ap Sa>=21 22s 2 M
+R p 1946 o - Ap Sa>=1 23s 1 S
+R p 1946 o - O Sa>=1 23s 0 -
+R p 1947 1966 - Ap Su>=1 2s 1 S
+R p 1947 1965 - O Su>=1 2s 0 -
+R p 1976 o - S lastSu 1 0 -
+R p 1977 o - Mar lastSu 0s 1 S
+R p 1977 o - S lastSu 0s 0 -
+R p 1978 1980 - Ap Su>=1 1s 1 S
+R p 1978 o - O 1 1s 0 -
+R p 1979 1980 - S lastSu 1s 0 -
+R p 1981 1986 - Mar lastSu 0s 1 S
+R p 1981 1985 - S lastSu 0s 0 -
+R z 1932 o - May 21 0s 1 S
+R z 1932 1939 - O Su>=1 0s 0 -
+R z 1933 1939 - Ap Su>=2 0s 1 S
+R z 1979 o - May 27 0 1 S
+R z 1979 o - S lastSu 0 0 -
+R z 1980 o - Ap 5 23 1 S
+R z 1980 o - S lastSu 1 0 -
+R z 1991 1993 - Mar lastSu 0s 1 S
+R z 1991 1993 - S lastSu 0s 0 -
+R s 1918 o - Ap 15 23 1 S
+R s 1918 1919 - O 6 24s 0 -
+R s 1919 o - Ap 6 23 1 S
+R s 1924 o - Ap 16 23 1 S
+R s 1924 o - O 4 24s 0 -
+R s 1926 o - Ap 17 23 1 S
+R s 1926 1929 - O Sa>=1 24s 0 -
+R s 1927 o - Ap 9 23 1 S
+R s 1928 o - Ap 15 0 1 S
+R s 1929 o - Ap 20 23 1 S
+R s 1937 o - Jun 16 23 1 S
+R s 1937 o - O 2 24s 0 -
+R s 1938 o - Ap 2 23 1 S
+R s 1938 o - Ap 30 23 2 M
+R s 1938 o - O 2 24 1 S
+R s 1939 o - O 7 24s 0 -
+R s 1942 o - May 2 23 1 S
+R s 1942 o - S 1 1 0 -
+R s 1943 1946 - Ap Sa>=13 23 1 S
+R s 1943 1944 - O Su>=1 1 0 -
+R s 1945 1946 - S lastSu 1 0 -
+R s 1949 o - Ap 30 23 1 S
+R s 1949 o - O 2 1 0 -
+R s 1974 1975 - Ap Sa>=12 23 1 S
+R s 1974 1975 - O Su>=1 1 0 -
+R s 1976 o - Mar 27 23 1 S
+R s 1976 1977 - S lastSu 1 0 -
+R s 1977 o - Ap 2 23 1 S
+R s 1978 o - Ap 2 2s 1 S
+R s 1978 o - O 1 2s 0 -
+R Sp 1967 o - Jun 3 12 1 S
+R Sp 1967 o - O 1 0 0 -
+R Sp 1974 o - Jun 24 0 1 S
+R Sp 1974 o - S 1 0 0 -
+R Sp 1976 1977 - May 1 0 1 S
+R Sp 1976 o - Au 1 0 0 -
+R Sp 1977 o - S 28 0 0 -
+R Sp 1978 o - Jun 1 0 1 S
+R Sp 1978 o - Au 4 0 0 -
+R CH 1941 1942 - May M>=1 1 1 S
+R CH 1941 1942 - O M>=1 2 0 -
+R T 1916 o - May 1 0 1 S
+R T 1916 o - O 1 0 0 -
+R T 1920 o - Mar 28 0 1 S
+R T 1920 o - O 25 0 0 -
+R T 1921 o - Ap 3 0 1 S
+R T 1921 o - O 3 0 0 -
+R T 1922 o - Mar 26 0 1 S
+R T 1922 o - O 8 0 0 -
+R T 1924 o - May 13 0 1 S
+R T 1924 1925 - O 1 0 0 -
+R T 1925 o - May 1 0 1 S
+R T 1940 o - Jul 1 0 1 S
+R T 1940 o - O 6 0 0 -
+R T 1940 o - D 1 0 1 S
+R T 1941 o - S 21 0 0 -
+R T 1942 o - Ap 1 0 1 S
+R T 1945 o - O 8 0 0 -
+R T 1946 o - Jun 1 0 1 S
+R T 1946 o - O 1 0 0 -
+R T 1947 1948 - Ap Su>=16 0 1 S
+R T 1947 1951 - O Su>=2 0 0 -
+R T 1949 o - Ap 10 0 1 S
+R T 1950 o - Ap 16 0 1 S
+R T 1951 o - Ap 22 0 1 S
+R T 1962 o - Jul 15 0 1 S
+R T 1963 o - O 30 0 0 -
+R T 1964 o - May 15 0 1 S
+R T 1964 o - O 1 0 0 -
+R T 1973 o - Jun 3 1 1 S
+R T 1973 1976 - O Su>=31 2 0 -
+R T 1974 o - Mar 31 2 1 S
+R T 1975 o - Mar 22 2 1 S
+R T 1976 o - Mar 21 2 1 S
+R T 1977 1978 - Ap Su>=1 2 1 S
+R T 1977 1978 - O Su>=15 2 0 -
+R T 1978 o - Jun 29 0 0 -
+R T 1983 o - Jul 31 2 1 S
+R T 1983 o - O 2 2 0 -
+R T 1985 o - Ap 20 1s 1 S
+R T 1985 o - S 28 1s 0 -
+R T 1986 1993 - Mar lastSu 1s 1 S
+R T 1986 1995 - S lastSu 1s 0 -
+R T 1994 o - Mar 20 1s 1 S
+R T 1995 2006 - Mar lastSu 1s 1 S
+R T 1996 2006 - O lastSu 1s 0 -
+R u 1918 1919 - Mar lastSu 2 1 D
+R u 1918 1919 - O lastSu 2 0 S
+R u 1942 o - F 9 2 1 W
+R u 1945 o - Au 14 23u 1 P
+R u 1945 o - S 30 2 0 S
+R u 1967 2006 - O lastSu 2 0 S
+R u 1967 1973 - Ap lastSu 2 1 D
+R u 1974 o - Ja 6 2 1 D
+R u 1975 o - F lastSu 2 1 D
+R u 1976 1986 - Ap lastSu 2 1 D
+R u 1987 2006 - Ap Su>=1 2 1 D
+R u 2007 ma - Mar Su>=8 2 1 D
+R u 2007 ma - N Su>=1 2 0 S
+R NY 1920 o - Mar lastSu 2 1 D
+R NY 1920 o - O lastSu 2 0 S
+R NY 1921 1966 - Ap lastSu 2 1 D
+R NY 1921 1954 - S lastSu 2 0 S
+R NY 1955 1966 - O lastSu 2 0 S
+R Ch 1920 o - Jun 13 2 1 D
+R Ch 1920 1921 - O lastSu 2 0 S
+R Ch 1921 o - Mar lastSu 2 1 D
+R Ch 1922 1966 - Ap lastSu 2 1 D
+R Ch 1922 1954 - S lastSu 2 0 S
+R Ch 1955 1966 - O lastSu 2 0 S
+R De 1920 1921 - Mar lastSu 2 1 D
+R De 1920 o - O lastSu 2 0 S
+R De 1921 o - May 22 2 0 S
+R De 1965 1966 - Ap lastSu 2 1 D
+R De 1965 1966 - O lastSu 2 0 S
+R CA 1948 o - Mar 14 2:1 1 D
+R CA 1949 o - Ja 1 2 0 S
+R CA 1950 1966 - Ap lastSu 1 1 D
+R CA 1950 1961 - S lastSu 2 0 S
+R CA 1962 1966 - O lastSu 2 0 S
+R In 1941 o - Jun 22 2 1 D
+R In 1941 1954 - S lastSu 2 0 S
+R In 1946 1954 - Ap lastSu 2 1 D
+R Ma 1951 o - Ap lastSu 2 1 D
+R Ma 1951 o - S lastSu 2 0 S
+R Ma 1954 1960 - Ap lastSu 2 1 D
+R Ma 1954 1960 - S lastSu 2 0 S
+R V 1946 o - Ap lastSu 2 1 D
+R V 1946 o - S lastSu 2 0 S
+R V 1953 1954 - Ap lastSu 2 1 D
+R V 1953 1959 - S lastSu 2 0 S
+R V 1955 o - May 1 0 1 D
+R V 1956 1963 - Ap lastSu 2 1 D
+R V 1960 o - O lastSu 2 0 S
+R V 1961 o - S lastSu 2 0 S
+R V 1962 1963 - O lastSu 2 0 S
+R Pe 1955 o - May 1 0 1 D
+R Pe 1955 1960 - S lastSu 2 0 S
+R Pe 1956 1963 - Ap lastSu 2 1 D
+R Pe 1961 1963 - O lastSu 2 0 S
+R Pi 1955 o - May 1 0 1 D
+R Pi 1955 1960 - S lastSu 2 0 S
+R Pi 1956 1964 - Ap lastSu 2 1 D
+R Pi 1961 1964 - O lastSu 2 0 S
+R St 1947 1961 - Ap lastSu 2 1 D
+R St 1947 1954 - S lastSu 2 0 S
+R St 1955 1956 - O lastSu 2 0 S
+R St 1957 1958 - S lastSu 2 0 S
+R St 1959 1961 - O lastSu 2 0 S
+R Pu 1946 1960 - Ap lastSu 2 1 D
+R Pu 1946 1954 - S lastSu 2 0 S
+R Pu 1955 1956 - O lastSu 2 0 S
+R Pu 1957 1960 - S lastSu 2 0 S
+R v 1921 o - May 1 2 1 D
+R v 1921 o - S 1 2 0 S
+R v 1941 o - Ap lastSu 2 1 D
+R v 1941 o - S lastSu 2 0 S
+R v 1946 o - Ap lastSu 0:1 1 D
+R v 1946 o - Jun 2 2 0 S
+R v 1950 1961 - Ap lastSu 2 1 D
+R v 1950 1955 - S lastSu 2 0 S
+R v 1956 1961 - O lastSu 2 0 S
+R Dt 1948 o - Ap lastSu 2 1 D
+R Dt 1948 o - S lastSu 2 0 S
+R Me 1946 o - Ap lastSu 2 1 D
+R Me 1946 o - S lastSu 2 0 S
+R Me 1966 o - Ap lastSu 2 1 D
+R Me 1966 o - O lastSu 2 0 S
+R C 1918 o - Ap 14 2 1 D
+R C 1918 o - O 27 2 0 S
+R C 1942 o - F 9 2 1 W
+R C 1945 o - Au 14 23u 1 P
+R C 1945 o - S 30 2 0 S
+R C 1974 1986 - Ap lastSu 2 1 D
+R C 1974 2006 - O lastSu 2 0 S
+R C 1987 2006 - Ap Su>=1 2 1 D
+R C 2007 ma - Mar Su>=8 2 1 D
+R C 2007 ma - N Su>=1 2 0 S
+R j 1917 o - Ap 8 2 1 D
+R j 1917 o - S 17 2 0 S
+R j 1919 o - May 5 23 1 D
+R j 1919 o - Au 12 23 0 S
+R j 1920 1935 - May Su>=1 23 1 D
+R j 1920 1935 - O lastSu 23 0 S
+R j 1936 1941 - May M>=9 0 1 D
+R j 1936 1941 - O M>=2 0 0 S
+R j 1946 1950 - May Su>=8 2 1 D
+R j 1946 1950 - O Su>=2 2 0 S
+R j 1951 1986 - Ap lastSu 2 1 D
+R j 1951 1959 - S lastSu 2 0 S
+R j 1960 1986 - O lastSu 2 0 S
+R j 1987 o - Ap Su>=1 0:1 1 D
+R j 1987 2006 - O lastSu 0:1 0 S
+R j 1988 o - Ap Su>=1 0:1 2 DD
+R j 1989 2006 - Ap Su>=1 0:1 1 D
+R j 2007 2011 - Mar Su>=8 0:1 1 D
+R j 2007 2010 - N Su>=1 0:1 0 S
+R H 1916 o - Ap 1 0 1 D
+R H 1916 o - O 1 0 0 S
+R H 1920 o - May 9 0 1 D
+R H 1920 o - Au 29 0 0 S
+R H 1921 o - May 6 0 1 D
+R H 1921 1922 - S 5 0 0 S
+R H 1922 o - Ap 30 0 1 D
+R H 1923 1925 - May Su>=1 0 1 D
+R H 1923 o - S 4 0 0 S
+R H 1924 o - S 15 0 0 S
+R H 1925 o - S 28 0 0 S
+R H 1926 o - May 16 0 1 D
+R H 1926 o - S 13 0 0 S
+R H 1927 o - May 1 0 1 D
+R H 1927 o - S 26 0 0 S
+R H 1928 1931 - May Su>=8 0 1 D
+R H 1928 o - S 9 0 0 S
+R H 1929 o - S 3 0 0 S
+R H 1930 o - S 15 0 0 S
+R H 1931 1932 - S M>=24 0 0 S
+R H 1932 o - May 1 0 1 D
+R H 1933 o - Ap 30 0 1 D
+R H 1933 o - O 2 0 0 S
+R H 1934 o - May 20 0 1 D
+R H 1934 o - S 16 0 0 S
+R H 1935 o - Jun 2 0 1 D
+R H 1935 o - S 30 0 0 S
+R H 1936 o - Jun 1 0 1 D
+R H 1936 o - S 14 0 0 S
+R H 1937 1938 - May Su>=1 0 1 D
+R H 1937 1941 - S M>=24 0 0 S
+R H 1939 o - May 28 0 1 D
+R H 1940 1941 - May Su>=1 0 1 D
+R H 1946 1949 - Ap lastSu 2 1 D
+R H 1946 1949 - S lastSu 2 0 S
+R H 1951 1954 - Ap lastSu 2 1 D
+R H 1951 1954 - S lastSu 2 0 S
+R H 1956 1959 - Ap lastSu 2 1 D
+R H 1956 1959 - S lastSu 2 0 S
+R H 1962 1973 - Ap lastSu 2 1 D
+R H 1962 1973 - O lastSu 2 0 S
+R o 1933 1935 - Jun Su>=8 1 1 D
+R o 1933 1935 - S Su>=8 1 0 S
+R o 1936 1938 - Jun Su>=1 1 1 D
+R o 1936 1938 - S Su>=1 1 0 S
+R o 1939 o - May 27 1 1 D
+R o 1939 1941 - S Sa>=21 1 0 S
+R o 1940 o - May 19 1 1 D
+R o 1941 o - May 4 1 1 D
+R o 1946 1972 - Ap lastSu 2 1 D
+R o 1946 1956 - S lastSu 2 0 S
+R o 1957 1972 - O lastSu 2 0 S
+R o 1993 2006 - Ap Su>=1 0:1 1 D
+R o 1993 2006 - O lastSu 0:1 0 S
+R t 1919 o - Mar 30 23:30 1 D
+R t 1919 o - O 26 0 0 S
+R t 1920 o - May 2 2 1 D
+R t 1920 o - S 26 0 0 S
+R t 1921 o - May 15 2 1 D
+R t 1921 o - S 15 2 0 S
+R t 1922 1923 - May Su>=8 2 1 D
+R t 1922 1926 - S Su>=15 2 0 S
+R t 1924 1927 - May Su>=1 2 1 D
+R t 1927 1937 - S Su>=25 2 0 S
+R t 1928 1937 - Ap Su>=25 2 1 D
+R t 1938 1940 - Ap lastSu 2 1 D
+R t 1938 1939 - S lastSu 2 0 S
+R t 1945 1948 - S lastSu 2 0 S
+R t 1946 1973 - Ap lastSu 2 1 D
+R t 1949 1950 - N lastSu 2 0 S
+R t 1951 1956 - S lastSu 2 0 S
+R t 1957 1973 - O lastSu 2 0 S
+R W 1916 o - Ap 23 0 1 D
+R W 1916 o - S 17 0 0 S
+R W 1918 o - Ap 14 2 1 D
+R W 1918 o - O 27 2 0 S
+R W 1937 o - May 16 2 1 D
+R W 1937 o - S 26 2 0 S
+R W 1942 o - F 9 2 1 W
+R W 1945 o - Au 14 23u 1 P
+R W 1945 o - S lastSu 2 0 S
+R W 1946 o - May 12 2 1 D
+R W 1946 o - O 13 2 0 S
+R W 1947 1949 - Ap lastSu 2 1 D
+R W 1947 1949 - S lastSu 2 0 S
+R W 1950 o - May 1 2 1 D
+R W 1950 o - S 30 2 0 S
+R W 1951 1960 - Ap lastSu 2 1 D
+R W 1951 1958 - S lastSu 2 0 S
+R W 1959 o - O lastSu 2 0 S
+R W 1960 o - S lastSu 2 0 S
+R W 1963 o - Ap lastSu 2 1 D
+R W 1963 o - S 22 2 0 S
+R W 1966 1986 - Ap lastSu 2s 1 D
+R W 1966 2005 - O lastSu 2s 0 S
+R W 1987 2005 - Ap Su>=1 2s 1 D
+R r 1918 o - Ap 14 2 1 D
+R r 1918 o - O 27 2 0 S
+R r 1930 1934 - May Su>=1 0 1 D
+R r 1930 1934 - O Su>=1 0 0 S
+R r 1937 1941 - Ap Su>=8 0 1 D
+R r 1937 o - O Su>=8 0 0 S
+R r 1938 o - O Su>=1 0 0 S
+R r 1939 1941 - O Su>=8 0 0 S
+R r 1942 o - F 9 2 1 W
+R r 1945 o - Au 14 23u 1 P
+R r 1945 o - S lastSu 2 0 S
+R r 1946 o - Ap Su>=8 2 1 D
+R r 1946 o - O Su>=8 2 0 S
+R r 1947 1957 - Ap lastSu 2 1 D
+R r 1947 1957 - S lastSu 2 0 S
+R r 1959 o - Ap lastSu 2 1 D
+R r 1959 o - O lastSu 2 0 S
+R Sw 1957 o - Ap lastSu 2 1 D
+R Sw 1957 o - O lastSu 2 0 S
+R Sw 1959 1961 - Ap lastSu 2 1 D
+R Sw 1959 o - O lastSu 2 0 S
+R Sw 1960 1961 - S lastSu 2 0 S
+R Ed 1918 1919 - Ap Su>=8 2 1 D
+R Ed 1918 o - O 27 2 0 S
+R Ed 1919 o - May 27 2 0 S
+R Ed 1920 1923 - Ap lastSu 2 1 D
+R Ed 1920 o - O lastSu 2 0 S
+R Ed 1921 1923 - S lastSu 2 0 S
+R Ed 1942 o - F 9 2 1 W
+R Ed 1945 o - Au 14 23u 1 P
+R Ed 1945 o - S lastSu 2 0 S
+R Ed 1947 o - Ap lastSu 2 1 D
+R Ed 1947 o - S lastSu 2 0 S
+R Ed 1972 1986 - Ap lastSu 2 1 D
+R Ed 1972 2006 - O lastSu 2 0 S
+R Va 1918 o - Ap 14 2 1 D
+R Va 1918 o - O 27 2 0 S
+R Va 1942 o - F 9 2 1 W
+R Va 1945 o - Au 14 23u 1 P
+R Va 1945 o - S 30 2 0 S
+R Va 1946 1986 - Ap lastSu 2 1 D
+R Va 1946 o - S 29 2 0 S
+R Va 1947 1961 - S lastSu 2 0 S
+R Va 1962 2006 - O lastSu 2 0 S
+R Y 1918 o - Ap 14 2 1 D
+R Y 1918 o - O 27 2 0 S
+R Y 1919 o - May 25 2 1 D
+R Y 1919 o - N 1 0 0 S
+R Y 1942 o - F 9 2 1 W
+R Y 1945 o - Au 14 23u 1 P
+R Y 1945 o - S 30 2 0 S
+R Y 1972 1986 - Ap lastSu 2 1 D
+R Y 1972 2006 - O lastSu 2 0 S
+R Y 1987 2006 - Ap Su>=1 2 1 D
+R Yu 1965 o - Ap lastSu 0 2 DD
+R Yu 1965 o - O lastSu 2 0 S
+R m 1931 o - Ap 30 0 1 D
+R m 1931 o - O 1 0 0 S
+R m 1939 o - F 5 0 1 D
+R m 1939 o - Jun 25 0 0 S
+R m 1940 o - D 9 0 1 D
+R m 1941 o - Ap 1 0 0 S
+R m 1943 o - D 16 0 1 W
+R m 1944 o - May 1 0 0 S
+R m 1950 o - F 12 0 1 D
+R m 1950 o - Jul 30 0 0 S
+R m 1996 2000 - Ap Su>=1 2 1 D
+R m 1996 2000 - O lastSu 2 0 S
+R m 2001 o - May Su>=1 2 1 D
+R m 2001 o - S lastSu 2 0 S
+R m 2002 2022 - Ap Su>=1 2 1 D
+R m 2002 2022 - O lastSu 2 0 S
+R BB 1942 o - Ap 19 5u 1 D
+R BB 1942 o - Au 31 6u 0 S
+R BB 1943 o - May 2 5u 1 D
+R BB 1943 o - S 5 6u 0 S
+R BB 1944 o - Ap 10 5u 0:30 -
+R BB 1944 o - S 10 6u 0 S
+R BB 1977 o - Jun 12 2 1 D
+R BB 1977 1978 - O Su>=1 2 0 S
+R BB 1978 1980 - Ap Su>=15 2 1 D
+R BB 1979 o - S 30 2 0 S
+R BB 1980 o - S 25 2 0 S
+R BZ 1918 1941 - O Sa>=1 24 0:30 -0530
+R BZ 1919 1942 - F Sa>=8 24 0 CST
+R BZ 1942 o - Jun 27 24 1 CWT
+R BZ 1945 o - Au 14 23u 1 CPT
+R BZ 1945 o - D 15 24 0 CST
+R BZ 1947 1967 - O Sa>=1 24 0:30 -0530
+R BZ 1948 1968 - F Sa>=8 24 0 CST
+R BZ 1973 o - D 5 0 1 CDT
+R BZ 1974 o - F 9 0 0 CST
+R BZ 1982 o - D 18 0 1 CDT
+R BZ 1983 o - F 12 0 0 CST
+R Be 1917 o - Ap 5 24 1 -
+R Be 1917 o - S 30 24 0 -
+R Be 1918 o - Ap 13 24 1 -
+R Be 1918 o - S 15 24 0 S
+R Be 1942 o - Ja 11 2 1 D
+R Be 1942 o - O 18 2 0 S
+R Be 1943 o - Mar 21 2 1 D
+R Be 1943 o - O 31 2 0 S
+R Be 1944 1945 - Mar Su>=8 2 1 D
+R Be 1944 1945 - N Su>=1 2 0 S
+R Be 1947 o - May Su>=15 2 1 D
+R Be 1947 o - S Su>=8 2 0 S
+R Be 1948 1952 - May Su>=22 2 1 D
+R Be 1948 1952 - S Su>=1 2 0 S
+R Be 1956 o - May Su>=22 2 1 D
+R Be 1956 o - O lastSu 2 0 S
+R CR 1979 1980 - F lastSu 0 1 D
+R CR 1979 1980 - Jun Su>=1 0 0 S
+R CR 1991 1992 - Ja Sa>=15 0 1 D
+R CR 1991 o - Jul 1 0 0 S
+R CR 1992 o - Mar 15 0 0 S
+R Q 1928 o - Jun 10 0 1 D
+R Q 1928 o - O 10 0 0 S
+R Q 1940 1942 - Jun Su>=1 0 1 D
+R Q 1940 1942 - S Su>=1 0 0 S
+R Q 1945 1946 - Jun Su>=1 0 1 D
+R Q 1945 1946 - S Su>=1 0 0 S
+R Q 1965 o - Jun 1 0 1 D
+R Q 1965 o - S 30 0 0 S
+R Q 1966 o - May 29 0 1 D
+R Q 1966 o - O 2 0 0 S
+R Q 1967 o - Ap 8 0 1 D
+R Q 1967 1968 - S Su>=8 0 0 S
+R Q 1968 o - Ap 14 0 1 D
+R Q 1969 1977 - Ap lastSu 0 1 D
+R Q 1969 1971 - O lastSu 0 0 S
+R Q 1972 1974 - O 8 0 0 S
+R Q 1975 1977 - O lastSu 0 0 S
+R Q 1978 o - May 7 0 1 D
+R Q 1978 1990 - O Su>=8 0 0 S
+R Q 1979 1980 - Mar Su>=15 0 1 D
+R Q 1981 1985 - May Su>=5 0 1 D
+R Q 1986 1989 - Mar Su>=14 0 1 D
+R Q 1990 1997 - Ap Su>=1 0 1 D
+R Q 1991 1995 - O Su>=8 0s 0 S
+R Q 1996 o - O 6 0s 0 S
+R Q 1997 o - O 12 0s 0 S
+R Q 1998 1999 - Mar lastSu 0s 1 D
+R Q 1998 2003 - O lastSu 0s 0 S
+R Q 2000 2003 - Ap Su>=1 0s 1 D
+R Q 2004 o - Mar lastSu 0s 1 D
+R Q 2006 2010 - O lastSu 0s 0 S
+R Q 2007 o - Mar Su>=8 0s 1 D
+R Q 2008 o - Mar Su>=15 0s 1 D
+R Q 2009 2010 - Mar Su>=8 0s 1 D
+R Q 2011 o - Mar Su>=15 0s 1 D
+R Q 2011 o - N 13 0s 0 S
+R Q 2012 o - Ap 1 0s 1 D
+R Q 2012 ma - N Su>=1 0s 0 S
+R Q 2013 ma - Mar Su>=8 0s 1 D
+R DO 1966 o - O 30 0 1 EDT
+R DO 1967 o - F 28 0 0 EST
+R DO 1969 1973 - O lastSu 0 0:30 -0430
+R DO 1970 o - F 21 0 0 EST
+R DO 1971 o - Ja 20 0 0 EST
+R DO 1972 1974 - Ja 21 0 0 EST
+R SV 1987 1988 - May Su>=1 0 1 D
+R SV 1987 1988 - S lastSu 0 0 S
+R GT 1973 o - N 25 0 1 D
+R GT 1974 o - F 24 0 0 S
+R GT 1983 o - May 21 0 1 D
+R GT 1983 o - S 22 0 0 S
+R GT 1991 o - Mar 23 0 1 D
+R GT 1991 o - S 7 0 0 S
+R GT 2006 o - Ap 30 0 1 D
+R GT 2006 o - O 1 0 0 S
+R HT 1983 o - May 8 0 1 D
+R HT 1984 1987 - Ap lastSu 0 1 D
+R HT 1983 1987 - O lastSu 0 0 S
+R HT 1988 1997 - Ap Su>=1 1s 1 D
+R HT 1988 1997 - O lastSu 1s 0 S
+R HT 2005 2006 - Ap Su>=1 0 1 D
+R HT 2005 2006 - O lastSu 0 0 S
+R HT 2012 2015 - Mar Su>=8 2 1 D
+R HT 2012 2015 - N Su>=1 2 0 S
+R HT 2017 ma - Mar Su>=8 2 1 D
+R HT 2017 ma - N Su>=1 2 0 S
+R HN 1987 1988 - May Su>=1 0 1 D
+R HN 1987 1988 - S lastSu 0 0 S
+R HN 2006 o - May Su>=1 0 1 D
+R HN 2006 o - Au M>=1 0 0 S
+R NI 1979 1980 - Mar Su>=16 0 1 D
+R NI 1979 1980 - Jun M>=23 0 0 S
+R NI 2005 o - Ap 10 0 1 D
+R NI 2005 o - O Su>=1 0 0 S
+R NI 2006 o - Ap 30 2 1 D
+R NI 2006 o - O Su>=1 1 0 S
+R A 1930 o - D 1 0 1 -
+R A 1931 o - Ap 1 0 0 -
+R A 1931 o - O 15 0 1 -
+R A 1932 1940 - Mar 1 0 0 -
+R A 1932 1939 - N 1 0 1 -
+R A 1940 o - Jul 1 0 1 -
+R A 1941 o - Jun 15 0 0 -
+R A 1941 o - O 15 0 1 -
+R A 1943 o - Au 1 0 0 -
+R A 1943 o - O 15 0 1 -
+R A 1946 o - Mar 1 0 0 -
+R A 1946 o - O 1 0 1 -
+R A 1963 o - O 1 0 0 -
+R A 1963 o - D 15 0 1 -
+R A 1964 1966 - Mar 1 0 0 -
+R A 1964 1966 - O 15 0 1 -
+R A 1967 o - Ap 2 0 0 -
+R A 1967 1968 - O Su>=1 0 1 -
+R A 1968 1969 - Ap Su>=1 0 0 -
+R A 1974 o - Ja 23 0 1 -
+R A 1974 o - May 1 0 0 -
+R A 1988 o - D 1 0 1 -
+R A 1989 1993 - Mar Su>=1 0 0 -
+R A 1989 1992 - O Su>=15 0 1 -
+R A 1999 o - O Su>=1 0 1 -
+R A 2000 o - Mar 3 0 0 -
+R A 2007 o - D 30 0 1 -
+R A 2008 2009 - Mar Su>=15 0 0 -
+R A 2008 o - O Su>=15 0 1 -
+R Sa 2008 2009 - Mar Su>=8 0 0 -
+R Sa 2007 2008 - O Su>=8 0 1 -
+R B 1931 o - O 3 11 1 -
+R B 1932 1933 - Ap 1 0 0 -
+R B 1932 o - O 3 0 1 -
+R B 1949 1952 - D 1 0 1 -
+R B 1950 o - Ap 16 1 0 -
+R B 1951 1952 - Ap 1 0 0 -
+R B 1953 o - Mar 1 0 0 -
+R B 1963 o - D 9 0 1 -
+R B 1964 o - Mar 1 0 0 -
+R B 1965 o - Ja 31 0 1 -
+R B 1965 o - Mar 31 0 0 -
+R B 1965 o - D 1 0 1 -
+R B 1966 1968 - Mar 1 0 0 -
+R B 1966 1967 - N 1 0 1 -
+R B 1985 o - N 2 0 1 -
+R B 1986 o - Mar 15 0 0 -
+R B 1986 o - O 25 0 1 -
+R B 1987 o - F 14 0 0 -
+R B 1987 o - O 25 0 1 -
+R B 1988 o - F 7 0 0 -
+R B 1988 o - O 16 0 1 -
+R B 1989 o - Ja 29 0 0 -
+R B 1989 o - O 15 0 1 -
+R B 1990 o - F 11 0 0 -
+R B 1990 o - O 21 0 1 -
+R B 1991 o - F 17 0 0 -
+R B 1991 o - O 20 0 1 -
+R B 1992 o - F 9 0 0 -
+R B 1992 o - O 25 0 1 -
+R B 1993 o - Ja 31 0 0 -
+R B 1993 1995 - O Su>=11 0 1 -
+R B 1994 1995 - F Su>=15 0 0 -
+R B 1996 o - F 11 0 0 -
+R B 1996 o - O 6 0 1 -
+R B 1997 o - F 16 0 0 -
+R B 1997 o - O 6 0 1 -
+R B 1998 o - Mar 1 0 0 -
+R B 1998 o - O 11 0 1 -
+R B 1999 o - F 21 0 0 -
+R B 1999 o - O 3 0 1 -
+R B 2000 o - F 27 0 0 -
+R B 2000 2001 - O Su>=8 0 1 -
+R B 2001 2006 - F Su>=15 0 0 -
+R B 2002 o - N 3 0 1 -
+R B 2003 o - O 19 0 1 -
+R B 2004 o - N 2 0 1 -
+R B 2005 o - O 16 0 1 -
+R B 2006 o - N 5 0 1 -
+R B 2007 o - F 25 0 0 -
+R B 2007 o - O Su>=8 0 1 -
+R B 2008 2017 - O Su>=15 0 1 -
+R B 2008 2011 - F Su>=15 0 0 -
+R B 2012 o - F Su>=22 0 0 -
+R B 2013 2014 - F Su>=15 0 0 -
+R B 2015 o - F Su>=22 0 0 -
+R B 2016 2019 - F Su>=15 0 0 -
+R B 2018 o - N Su>=1 0 1 -
+R x 1927 1931 - S 1 0 1 -
+R x 1928 1932 - Ap 1 0 0 -
+R x 1968 o - N 3 4u 1 -
+R x 1969 o - Mar 30 3u 0 -
+R x 1969 o - N 23 4u 1 -
+R x 1970 o - Mar 29 3u 0 -
+R x 1971 o - Mar 14 3u 0 -
+R x 1970 1972 - O Su>=9 4u 1 -
+R x 1972 1986 - Mar Su>=9 3u 0 -
+R x 1973 o - S 30 4u 1 -
+R x 1974 1987 - O Su>=9 4u 1 -
+R x 1987 o - Ap 12 3u 0 -
+R x 1988 1990 - Mar Su>=9 3u 0 -
+R x 1988 1989 - O Su>=9 4u 1 -
+R x 1990 o - S 16 4u 1 -
+R x 1991 1996 - Mar Su>=9 3u 0 -
+R x 1991 1997 - O Su>=9 4u 1 -
+R x 1997 o - Mar 30 3u 0 -
+R x 1998 o - Mar Su>=9 3u 0 -
+R x 1998 o - S 27 4u 1 -
+R x 1999 o - Ap 4 3u 0 -
+R x 1999 2010 - O Su>=9 4u 1 -
+R x 2000 2007 - Mar Su>=9 3u 0 -
+R x 2008 o - Mar 30 3u 0 -
+R x 2009 o - Mar Su>=9 3u 0 -
+R x 2010 o - Ap Su>=1 3u 0 -
+R x 2011 o - May Su>=2 3u 0 -
+R x 2011 o - Au Su>=16 4u 1 -
+R x 2012 2014 - Ap Su>=23 3u 0 -
+R x 2012 2014 - S Su>=2 4u 1 -
+R x 2016 2018 - May Su>=9 3u 0 -
+R x 2016 2018 - Au Su>=9 4u 1 -
+R x 2019 ma - Ap Su>=2 3u 0 -
+R x 2019 2021 - S Su>=2 4u 1 -
+R x 2022 o - S Su>=9 4u 1 -
+R x 2023 ma - S Su>=2 4u 1 -
+R CO 1992 o - May 3 0 1 -
+R CO 1993 o - F 6 24 0 -
+R EC 1992 o - N 28 0 1 -
+R EC 1993 o - F 5 0 0 -
+R FK 1937 1938 - S lastSu 0 1 -
+R FK 1938 1942 - Mar Su>=19 0 0 -
+R FK 1939 o - O 1 0 1 -
+R FK 1940 1942 - S lastSu 0 1 -
+R FK 1943 o - Ja 1 0 0 -
+R FK 1983 o - S lastSu 0 1 -
+R FK 1984 1985 - Ap lastSu 0 0 -
+R FK 1984 o - S 16 0 1 -
+R FK 1985 2000 - S Su>=9 0 1 -
+R FK 1986 2000 - Ap Su>=16 0 0 -
+R FK 2001 2010 - Ap Su>=15 2 0 -
+R FK 2001 2010 - S Su>=1 2 1 -
+R y 1975 1988 - O 1 0 1 -
+R y 1975 1978 - Mar 1 0 0 -
+R y 1979 1991 - Ap 1 0 0 -
+R y 1989 o - O 22 0 1 -
+R y 1990 o - O 1 0 1 -
+R y 1991 o - O 6 0 1 -
+R y 1992 o - Mar 1 0 0 -
+R y 1992 o - O 5 0 1 -
+R y 1993 o - Mar 31 0 0 -
+R y 1993 1995 - O 1 0 1 -
+R y 1994 1995 - F lastSu 0 0 -
+R y 1996 o - Mar 1 0 0 -
+R y 1996 2001 - O Su>=1 0 1 -
+R y 1997 o - F lastSu 0 0 -
+R y 1998 2001 - Mar Su>=1 0 0 -
+R y 2002 2004 - Ap Su>=1 0 0 -
+R y 2002 2003 - S Su>=1 0 1 -
+R y 2004 2009 - O Su>=15 0 1 -
+R y 2005 2009 - Mar Su>=8 0 0 -
+R y 2010 2024 - O Su>=1 0 1 -
+R y 2010 2012 - Ap Su>=8 0 0 -
+R y 2013 2024 - Mar Su>=22 0 0 -
+R PE 1938 o - Ja 1 0 1 -
+R PE 1938 o - Ap 1 0 0 -
+R PE 1938 1939 - S lastSu 0 1 -
+R PE 1939 1940 - Mar Su>=24 0 0 -
+R PE 1986 1987 - Ja 1 0 1 -
+R PE 1986 1987 - Ap 1 0 0 -
+R PE 1990 o - Ja 1 0 1 -
+R PE 1990 o - Ap 1 0 0 -
+R PE 1994 o - Ja 1 0 1 -
+R PE 1994 o - Ap 1 0 0 -
+R U 1923 1925 - O 1 0 0:30 -
+R U 1924 1926 - Ap 1 0 0 -
+R U 1933 1938 - O lastSu 0 0:30 -
+R U 1934 1941 - Mar lastSa 24 0 -
+R U 1939 o - O 1 0 0:30 -
+R U 1940 o - O 27 0 0:30 -
+R U 1941 o - Au 1 0 0:30 -
+R U 1942 o - D 14 0 0:30 -
+R U 1943 o - Mar 14 0 0 -
+R U 1959 o - May 24 0 0:30 -
+R U 1959 o - N 15 0 0 -
+R U 1960 o - Ja 17 0 1 -
+R U 1960 o - Mar 6 0 0 -
+R U 1965 o - Ap 4 0 1 -
+R U 1965 o - S 26 0 0 -
+R U 1968 o - May 27 0 0:30 -
+R U 1968 o - D 1 0 0 -
+R U 1970 o - Ap 25 0 1 -
+R U 1970 o - Jun 14 0 0 -
+R U 1972 o - Ap 23 0 1 -
+R U 1972 o - Jul 16 0 0 -
+R U 1974 o - Ja 13 0 1:30 -
+R U 1974 o - Mar 10 0 0:30 -
+R U 1974 o - S 1 0 0 -
+R U 1974 o - D 22 0 1 -
+R U 1975 o - Mar 30 0 0 -
+R U 1976 o - D 19 0 1 -
+R U 1977 o - Mar 6 0 0 -
+R U 1977 o - D 4 0 1 -
+R U 1978 1979 - Mar Su>=1 0 0 -
+R U 1978 o - D 17 0 1 -
+R U 1979 o - Ap 29 0 1 -
+R U 1980 o - Mar 16 0 0 -
+R U 1987 o - D 14 0 1 -
+R U 1988 o - F 28 0 0 -
+R U 1988 o - D 11 0 1 -
+R U 1989 o - Mar 5 0 0 -
+R U 1989 o - O 29 0 1 -
+R U 1990 o - F 25 0 0 -
+R U 1990 1991 - O Su>=21 0 1 -
+R U 1991 1992 - Mar Su>=1 0 0 -
+R U 1992 o - O 18 0 1 -
+R U 1993 o - F 28 0 0 -
+R U 2004 o - S 19 0 1 -
+R U 2005 o - Mar 27 2 0 -
+R U 2005 o - O 9 2 1 -
+R U 2006 2015 - Mar Su>=8 2 0 -
+R U 2006 2014 - O Su>=1 2 1 -
+Z Africa/Abidjan -0:16:8 - LMT 1912
+0 - GMT
+Z Africa/Algiers 0:12:12 - LMT 1891 Mar 16
+0:9:21 - PMT 1911 Mar 11
+0 d WE%sT 1940 F 25 2
+1 d CE%sT 1946 O 7
+0 - WET 1956 Ja 29
+1 - CET 1963 Ap 14
+0 d WE%sT 1977 O 21
+1 d CE%sT 1979 O 26
+0 d WE%sT 1981 May
+1 - CET
+Z Africa/Bissau -1:2:20 - LMT 1912 Ja 1 1u
+-1 - %z 1975
+0 - GMT
+Z Africa/Cairo 2:5:9 - LMT 1900 O
+2 K EE%sT
+Z Africa/Casablanca -0:30:20 - LMT 1913 O 26
+0 M %z 1984 Mar 16
+1 - %z 1986
+0 M %z 2018 O 28 3
+1 M %z
+Z Africa/Ceuta -0:21:16 - LMT 1901 Ja 1 0u
+0 - WET 1918 May 6 23
+0 1 WEST 1918 O 7 23
+0 - WET 1924
+0 s WE%sT 1929
+0 - WET 1967
+0 Sp WE%sT 1984 Mar 16
+1 - CET 1986
+1 E CE%sT
+Z Africa/El_Aaiun -0:52:48 - LMT 1934
+-1 - %z 1976 Ap 14
+0 M %z 2018 O 28 3
+1 M %z
+Z Africa/Johannesburg 1:52 - LMT 1892 F 8
+1:30 - SAST 1903 Mar
+2 SA SAST
+Z Africa/Juba 2:6:28 - LMT 1931
+2 SD CA%sT 2000 Ja 15 12
+3 - EAT 2021 F
+2 - CAT
+Z Africa/Khartoum 2:10:8 - LMT 1931
+2 SD CA%sT 2000 Ja 15 12
+3 - EAT 2017 N
+2 - CAT
+Z Africa/Lagos 0:13:35 - LMT 1905 Jul
+0 - GMT 1908 Jul
+0:13:35 - LMT 1914
+0:30 - %z 1919 S
+1 - WAT
+Z Africa/Maputo 2:10:18 - LMT 1909
+2 - CAT
+Z Africa/Monrovia -0:43:8 - LMT 1882
+-0:43:8 - MMT 1919 Mar
+-0:44:30 - MMT 1972 Ja 7
+0 - GMT
+Z Africa/Nairobi 2:27:16 - LMT 1908 May
+2:30 - %z 1928 Jun 30 24
+3 - EAT 1930 Ja 4 24
+2:30 - %z 1936 D 31 24
+2:45 - %z 1942 Jul 31 24
+3 - EAT
+Z Africa/Ndjamena 1:0:12 - LMT 1912
+1 - WAT 1979 O 14
+1 1 WAST 1980 Mar 8
+1 - WAT
+Z Africa/Sao_Tome 0:26:56 - LMT 1884
+-0:36:45 - LMT 1912 Ja 1 0u
+0 - GMT 2018 Ja 1 1
+1 - WAT 2019 Ja 1 2
+0 - GMT
+Z Africa/Tripoli 0:52:44 - LMT 1920
+1 L CE%sT 1959
+2 - EET 1982
+1 L CE%sT 1990 May 4
+2 - EET 1996 S 30
+1 L CE%sT 1997 O 4
+2 - EET 2012 N 10 2
+1 L CE%sT 2013 O 25 2
+2 - EET
+Z Africa/Tunis 0:40:44 - LMT 1881 May 12
+0:9:21 - PMT 1911 Mar 11
+1 n CE%sT
+Z Africa/Windhoek 1:8:24 - LMT 1892 F 8
+1:30 - %z 1903 Mar
+2 - SAST 1942 S 20 2
+2 1 SAST 1943 Mar 21 2
+2 - SAST 1990 Mar 21
+2 NA %s
+Z America/Adak 12:13:22 - LMT 1867 O 19 12:44:35
+-11:46:38 - LMT 1900 Au 20 12
+-11 - NST 1942
+-11 u N%sT 1946
+-11 - NST 1967 Ap
+-11 - BST 1969
+-11 u B%sT 1983 O 30 2
+-10 u AH%sT 1983 N 30
+-10 u H%sT
+Z America/Anchorage 14:0:24 - LMT 1867 O 19 14:31:37
+-9:59:36 - LMT 1900 Au 20 12
+-10 - AST 1942
+-10 u A%sT 1967 Ap
+-10 - AHST 1969
+-10 u AH%sT 1983 O 30 2
+-9 u Y%sT 1983 N 30
+-9 u AK%sT
+Z America/Araguaina -3:12:48 - LMT 1914
+-3 B %z 1990 S 17
+-3 - %z 1995 S 14
+-3 B %z 2003 S 24
+-3 - %z 2012 O 21
+-3 B %z 2013 S
+-3 - %z
+Z America/Argentina/Buenos_Aires -3:53:48 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 A %z
+Z America/Argentina/Catamarca -4:23:8 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1991 Mar 3
+-4 - %z 1991 O 20
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 - %z 2004 Jun
+-4 - %z 2004 Jun 20
+-3 A %z 2008 O 18
+-3 - %z
+Z America/Argentina/Cordoba -4:16:48 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1991 Mar 3
+-4 - %z 1991 O 20
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 A %z
+Z America/Argentina/Jujuy -4:21:12 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1990 Mar 4
+-4 - %z 1990 O 28
+-4 1 %z 1991 Mar 17
+-4 - %z 1991 O 6
+-3 1 %z 1992
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 A %z 2008 O 18
+-3 - %z
+Z America/Argentina/La_Rioja -4:27:24 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1991 Mar
+-4 - %z 1991 May 7
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 - %z 2004 Jun
+-4 - %z 2004 Jun 20
+-3 A %z 2008 O 18
+-3 - %z
+Z America/Argentina/Mendoza -4:35:16 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1990 Mar 4
+-4 - %z 1990 O 15
+-4 1 %z 1991 Mar
+-4 - %z 1991 O 15
+-4 1 %z 1992 Mar
+-4 - %z 1992 O 18
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 - %z 2004 May 23
+-4 - %z 2004 S 26
+-3 A %z 2008 O 18
+-3 - %z
+Z America/Argentina/Rio_Gallegos -4:36:52 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 - %z 2004 Jun
+-4 - %z 2004 Jun 20
+-3 A %z 2008 O 18
+-3 - %z
+Z America/Argentina/Salta -4:21:40 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1991 Mar 3
+-4 - %z 1991 O 20
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 A %z 2008 O 18
+-3 - %z
+Z America/Argentina/San_Juan -4:34:4 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1991 Mar
+-4 - %z 1991 May 7
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 - %z 2004 May 31
+-4 - %z 2004 Jul 25
+-3 A %z 2008 O 18
+-3 - %z
+Z America/Argentina/San_Luis -4:25:24 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1990
+-3 1 %z 1990 Mar 14
+-4 - %z 1990 O 15
+-4 1 %z 1991 Mar
+-4 - %z 1991 Jun
+-3 - %z 1999 O 3
+-4 1 %z 2000 Mar 3
+-3 - %z 2004 May 31
+-4 - %z 2004 Jul 25
+-3 A %z 2008 Ja 21
+-4 Sa %z 2009 O 11
+-3 - %z
+Z America/Argentina/Tucuman -4:20:52 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1991 Mar 3
+-4 - %z 1991 O 20
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 - %z 2004 Jun
+-4 - %z 2004 Jun 13
+-3 A %z
+Z America/Argentina/Ushuaia -4:33:12 - LMT 1894 O 31
+-4:16:48 - CMT 1920 May
+-4 - %z 1930 D
+-4 A %z 1969 O 5
+-3 A %z 1999 O 3
+-4 A %z 2000 Mar 3
+-3 - %z 2004 May 30
+-4 - %z 2004 Jun 20
+-3 A %z 2008 O 18
+-3 - %z
+Z America/Asuncion -3:50:40 - LMT 1890
+-3:50:40 - AMT 1931 O 10
+-4 - %z 1972 O
+-3 - %z 1974 Ap
+-4 y %z 2024 O 15
+-3 - %z
+Z America/Bahia -2:34:4 - LMT 1914
+-3 B %z 2003 S 24
+-3 - %z 2011 O 16
+-3 B %z 2012 O 21
+-3 - %z
+Z America/Bahia_Banderas -7:1 - LMT 1922 Ja 1 7u
+-7 - MST 1927 Jun 10
+-6 - CST 1930 N 15
+-7 m M%sT 1932 Ap
+-6 - CST 1942 Ap 24
+-7 - MST 1970
+-7 m M%sT 2010 Ap 4 2
+-6 m C%sT
+Z America/Barbados -3:58:29 - LMT 1911 Au 28
+-4 BB A%sT 1944
+-4 BB AST/-0330 1945
+-4 BB A%sT
+Z America/Belem -3:13:56 - LMT 1914
+-3 B %z 1988 S 12
+-3 - %z
+Z America/Belize -5:52:48 - LMT 1912 Ap
+-6 BZ %s
+Z America/Boa_Vista -4:2:40 - LMT 1914
+-4 B %z 1988 S 12
+-4 - %z 1999 S 30
+-4 B %z 2000 O 15
+-4 - %z
+Z America/Bogota -4:56:16 - LMT 1884 Mar 13
+-4:56:16 - BMT 1914 N 23
+-5 CO %z
+Z America/Boise -7:44:49 - LMT 1883 N 18 20u
+-8 u P%sT 1923 May 13 2
+-7 u M%sT 1974
+-7 - MST 1974 F 3 2
+-7 u M%sT
+Z America/Cambridge_Bay 0 - -00 1920
+-7 Y M%sT 1999 O 31 2
+-6 C C%sT 2000 O 29 2
+-5 - EST 2000 N 5
+-6 - CST 2001 Ap 1 3
+-7 C M%sT
+Z America/Campo_Grande -3:38:28 - LMT 1914
+-4 B %z
+Z America/Cancun -5:47:4 - LMT 1922 Ja 1 6u
+-6 - CST 1981 D 26 2
+-5 - EST 1983 Ja 4
+-6 m C%sT 1997 O 26 2
+-5 m E%sT 1998 Au 2 2
+-6 m C%sT 2015 F 1 2
+-5 - EST
+Z America/Caracas -4:27:44 - LMT 1890
+-4:27:40 - CMT 1912 F 12
+-4:30 - %z 1965
+-4 - %z 2007 D 9 3
+-4:30 - %z 2016 May 1 2:30
+-4 - %z
+Z America/Cayenne -3:29:20 - LMT 1911 Jul
+-4 - %z 1967 O
+-3 - %z
+Z America/Chicago -5:50:36 - LMT 1883 N 18 18u
+-6 u C%sT 1920
+-6 Ch C%sT 1936 Mar 1 2
+-5 - EST 1936 N 15 2
+-6 Ch C%sT 1942
+-6 u C%sT 1946
+-6 Ch C%sT 1967
+-6 u C%sT
+Z America/Chihuahua -7:4:20 - LMT 1922 Ja 1 7u
+-7 - MST 1927 Jun 10
+-6 - CST 1930 N 15
+-7 m M%sT 1932 Ap
+-6 - CST 1996
+-6 m C%sT 1998
+-6 - CST 1998 Ap Su>=1 3
+-7 m M%sT 2022 O 30 2
+-6 - CST
+Z America/Ciudad_Juarez -7:5:56 - LMT 1922 Ja 1 7u
+-7 - MST 1927 Jun 10
+-6 - CST 1930 N 15
+-7 m M%sT 1932 Ap
+-6 - CST 1996
+-6 m C%sT 1998
+-6 - CST 1998 Ap Su>=1 3
+-7 m M%sT 2010
+-7 u M%sT 2022 O 30 2
+-6 - CST 2022 N 30
+-7 u M%sT
+Z America/Costa_Rica -5:36:13 - LMT 1890
+-5:36:13 - SJMT 1921 Ja 15
+-6 CR C%sT
+Z America/Cuiaba -3:44:20 - LMT 1914
+-4 B %z 2003 S 24
+-4 - %z 2004 O
+-4 B %z
+Z America/Danmarkshavn -1:14:40 - LMT 1916 Jul 28
+-3 - %z 1980 Ap 6 2
+-3 E %z 1996
+0 - GMT
+Z America/Dawson -9:17:40 - LMT 1900 Au 20
+-9 Y Y%sT 1965
+-9 Yu Y%sT 1973 O 28
+-8 - PST 1980
+-8 C P%sT 2020 N
+-7 - MST
+Z America/Dawson_Creek -8:0:56 - LMT 1884
+-8 C P%sT 1947
+-8 Va P%sT 1972 Au 30 2
+-7 - MST
+Z America/Denver -6:59:56 - LMT 1883 N 18 19u
+-7 u M%sT 1920
+-7 De M%sT 1942
+-7 u M%sT 1946
+-7 De M%sT 1967
+-7 u M%sT
+Z America/Detroit -5:32:11 - LMT 1905
+-6 - CST 1915 May 15 2
+-5 - EST 1942
+-5 u E%sT 1946
+-5 Dt E%sT 1967 Jun 14 0:1
+-5 u E%sT 1969
+-5 - EST 1973
+-5 u E%sT 1975
+-5 - EST 1975 Ap 27 2
+-5 u E%sT
+Z America/Edmonton -7:33:52 - LMT 1906 S
+-7 Ed M%sT 1987
+-7 C M%sT
+Z America/Eirunepe -4:39:28 - LMT 1914
+-5 B %z 1988 S 12
+-5 - %z 1993 S 28
+-5 B %z 1994 S 22
+-5 - %z 2008 Jun 24
+-4 - %z 2013 N 10
+-5 - %z
+Z America/El_Salvador -5:56:48 - LMT 1921
+-6 SV C%sT
+Z America/Fort_Nelson -8:10:47 - LMT 1884
+-8 Va P%sT 1946
+-8 - PST 1947
+-8 Va P%sT 1987
+-8 C P%sT 2015 Mar 8 2
+-7 - MST
+Z America/Fortaleza -2:34 - LMT 1914
+-3 B %z 1990 S 17
+-3 - %z 1999 S 30
+-3 B %z 2000 O 22
+-3 - %z 2001 S 13
+-3 B %z 2002 O
+-3 - %z
+Z America/Glace_Bay -3:59:48 - LMT 1902 Jun 15
+-4 C A%sT 1953
+-4 H A%sT 1954
+-4 - AST 1972
+-4 H A%sT 1974
+-4 C A%sT
+Z America/Goose_Bay -4:1:40 - LMT 1884
+-3:30:52 - NST 1918
+-3:30:52 C N%sT 1919
+-3:30:52 - NST 1935 Mar 30
+-3:30 - NST 1936
+-3:30 j N%sT 1942 May 11
+-3:30 C N%sT 1946
+-3:30 j N%sT 1966 Mar 15 2
+-4 j A%sT 2011 N
+-4 C A%sT
+Z America/Grand_Turk -4:44:32 - LMT 1890
+-5:7:10 - KMT 1912 F
+-5 - EST 1979
+-5 u E%sT 2015 Mar 8 2
+-4 - AST 2018 Mar 11 3
+-5 u E%sT
+Z America/Guatemala -6:2:4 - LMT 1918 O 5
+-6 GT C%sT
+Z America/Guayaquil -5:19:20 - LMT 1890
+-5:14 - QMT 1931
+-5 EC %z
+Z America/Guyana -3:52:39 - LMT 1911 Au
+-4 - %z 1915 Mar
+-3:45 - %z 1975 Au
+-3 - %z 1992 Mar 29 1
+-4 - %z
+Z America/Halifax -4:14:24 - LMT 1902 Jun 15
+-4 H A%sT 1918
+-4 C A%sT 1919
+-4 H A%sT 1942 F 9 2s
+-4 C A%sT 1946
+-4 H A%sT 1974
+-4 C A%sT
+Z America/Havana -5:29:28 - LMT 1890
+-5:29:36 - HMT 1925 Jul 19 12
+-5 Q C%sT
+Z America/Hermosillo -7:23:52 - LMT 1922 Ja 1 7u
+-7 - MST 1927 Jun 10
+-6 - CST 1930 N 15
+-7 m M%sT 1932 Ap
+-6 - CST 1942 Ap 24
+-7 - MST 1996
+-7 m M%sT 1999
+-7 - MST
+Z America/Indiana/Indianapolis -5:44:38 - LMT 1883 N 18 18u
+-6 u C%sT 1920
+-6 In C%sT 1942
+-6 u C%sT 1946
+-6 In C%sT 1955 Ap 24 2
+-5 - EST 1957 S 29 2
+-6 - CST 1958 Ap 27 2
+-5 - EST 1969
+-5 u E%sT 1971
+-5 - EST 2006
+-5 u E%sT
+Z America/Indiana/Knox -5:46:30 - LMT 1883 N 18 18u
+-6 u C%sT 1947
+-6 St C%sT 1962 Ap 29 2
+-5 - EST 1963 O 27 2
+-6 u C%sT 1991 O 27 2
+-5 - EST 2006 Ap 2 2
+-6 u C%sT
+Z America/Indiana/Marengo -5:45:23 - LMT 1883 N 18 18u
+-6 u C%sT 1951
+-6 Ma C%sT 1961 Ap 30 2
+-5 - EST 1969
+-5 u E%sT 1974 Ja 6 2
+-6 1 CDT 1974 O 27 2
+-5 u E%sT 1976
+-5 - EST 2006
+-5 u E%sT
+Z America/Indiana/Petersburg -5:49:7 - LMT 1883 N 18 18u
+-6 u C%sT 1955
+-6 Pi C%sT 1965 Ap 25 2
+-5 - EST 1966 O 30 2
+-6 u C%sT 1977 O 30 2
+-5 - EST 2006 Ap 2 2
+-6 u C%sT 2007 N 4 2
+-5 u E%sT
+Z America/Indiana/Tell_City -5:47:3 - LMT 1883 N 18 18u
+-6 u C%sT 1946
+-6 Pe C%sT 1964 Ap 26 2
+-5 - EST 1967 O 29 2
+-6 u C%sT 1969 Ap 27 2
+-5 u E%sT 1971
+-5 - EST 2006 Ap 2 2
+-6 u C%sT
+Z America/Indiana/Vevay -5:40:16 - LMT 1883 N 18 18u
+-6 u C%sT 1954 Ap 25 2
+-5 - EST 1969
+-5 u E%sT 1973
+-5 - EST 2006
+-5 u E%sT
+Z America/Indiana/Vincennes -5:50:7 - LMT 1883 N 18 18u
+-6 u C%sT 1946
+-6 V C%sT 1964 Ap 26 2
+-5 - EST 1969
+-5 u E%sT 1971
+-5 - EST 2006 Ap 2 2
+-6 u C%sT 2007 N 4 2
+-5 u E%sT
+Z America/Indiana/Winamac -5:46:25 - LMT 1883 N 18 18u
+-6 u C%sT 1946
+-6 Pu C%sT 1961 Ap 30 2
+-5 - EST 1969
+-5 u E%sT 1971
+-5 - EST 2006 Ap 2 2
+-6 u C%sT 2007 Mar 11 2
+-5 u E%sT
+Z America/Inuvik 0 - -00 1953
+-8 Y P%sT 1979 Ap lastSu 2
+-7 Y M%sT 1980
+-7 C M%sT
+Z America/Iqaluit 0 - -00 1942 Au
+-5 Y E%sT 1999 O 31 2
+-6 C C%sT 2000 O 29 2
+-5 C E%sT
+Z America/Jamaica -5:7:10 - LMT 1890
+-5:7:10 - KMT 1912 F
+-5 - EST 1974
+-5 u E%sT 1984
+-5 - EST
+Z America/Juneau 15:2:19 - LMT 1867 O 19 15:33:32
+-8:57:41 - LMT 1900 Au 20 12
+-8 - PST 1942
+-8 u P%sT 1946
+-8 - PST 1969
+-8 u P%sT 1980 Ap 27 2
+-9 u Y%sT 1980 O 26 2
+-8 u P%sT 1983 O 30 2
+-9 u Y%sT 1983 N 30
+-9 u AK%sT
+Z America/Kentucky/Louisville -5:43:2 - LMT 1883 N 18 18u
+-6 u C%sT 1921
+-6 v C%sT 1942
+-6 u C%sT 1946
+-6 v C%sT 1961 Jul 23 2
+-5 - EST 1968
+-5 u E%sT 1974 Ja 6 2
+-6 1 CDT 1974 O 27 2
+-5 u E%sT
+Z America/Kentucky/Monticello -5:39:24 - LMT 1883 N 18 18u
+-6 u C%sT 1946
+-6 - CST 1968
+-6 u C%sT 2000 O 29 2
+-5 u E%sT
+Z America/La_Paz -4:32:36 - LMT 1890
+-4:32:36 - CMT 1931 O 15
+-4:32:36 1 BST 1932 Mar 21
+-4 - %z
+Z America/Lima -5:8:12 - LMT 1890
+-5:8:36 - LMT 1908 Jul 28
+-5 PE %z
+Z America/Los_Angeles -7:52:58 - LMT 1883 N 18 20u
+-8 u P%sT 1946
+-8 CA P%sT 1967
+-8 u P%sT
+Z America/Maceio -2:22:52 - LMT 1914
+-3 B %z 1990 S 17
+-3 - %z 1995 O 13
+-3 B %z 1996 S 4
+-3 - %z 1999 S 30
+-3 B %z 2000 O 22
+-3 - %z 2001 S 13
+-3 B %z 2002 O
+-3 - %z
+Z America/Managua -5:45:8 - LMT 1890
+-5:45:12 - MMT 1934 Jun 23
+-6 - CST 1973 May
+-5 - EST 1975 F 16
+-6 NI C%sT 1992 Ja 1 4
+-5 - EST 1992 S 24
+-6 - CST 1993
+-5 - EST 1997
+-6 NI C%sT
+Z America/Manaus -4:0:4 - LMT 1914
+-4 B %z 1988 S 12
+-4 - %z 1993 S 28
+-4 B %z 1994 S 22
+-4 - %z
+Z America/Martinique -4:4:20 - LMT 1890
+-4:4:20 - FFMT 1911 May
+-4 - AST 1980 Ap 6
+-4 1 ADT 1980 S 28
+-4 - AST
+Z America/Matamoros -6:30 - LMT 1922 Ja 1 6u
+-6 - CST 1988
+-6 u C%sT 1989
+-6 m C%sT 2010
+-6 u C%sT
+Z America/Mazatlan -7:5:40 - LMT 1922 Ja 1 7u
+-7 - MST 1927 Jun 10
+-6 - CST 1930 N 15
+-7 m M%sT 1932 Ap
+-6 - CST 1942 Ap 24
+-7 - MST 1970
+-7 m M%sT
+Z America/Menominee -5:50:27 - LMT 1885 S 18 12
+-6 u C%sT 1946
+-6 Me C%sT 1969 Ap 27 2
+-5 - EST 1973 Ap 29 2
+-6 u C%sT
+Z America/Merida -5:58:28 - LMT 1922 Ja 1 6u
+-6 - CST 1981 D 26 2
+-5 - EST 1982 N 2 2
+-6 m C%sT
+Z America/Metlakatla 15:13:42 - LMT 1867 O 19 15:44:55
+-8:46:18 - LMT 1900 Au 20 12
+-8 - PST 1942
+-8 u P%sT 1946
+-8 - PST 1969
+-8 u P%sT 1983 O 30 2
+-8 - PST 2015 N 1 2
+-9 u AK%sT 2018 N 4 2
+-8 - PST 2019 Ja 20 2
+-9 u AK%sT
+Z America/Mexico_City -6:36:36 - LMT 1922 Ja 1 7u
+-7 - MST 1927 Jun 10
+-6 - CST 1930 N 15
+-7 m M%sT 1932 Ap
+-6 m C%sT 2001 S 30 2
+-6 - CST 2002 F 20
+-6 m C%sT
+Z America/Miquelon -3:44:40 - LMT 1911 Jun 15
+-4 - AST 1980 May
+-3 - %z 1987
+-3 C %z
+Z America/Moncton -4:19:8 - LMT 1883 D 9
+-5 - EST 1902 Jun 15
+-4 C A%sT 1933
+-4 o A%sT 1942
+-4 C A%sT 1946
+-4 o A%sT 1973
+-4 C A%sT 1993
+-4 o A%sT 2007
+-4 C A%sT
+Z America/Monterrey -6:41:16 - LMT 1922 Ja 1 6u
+-7 - MST 1927 Jun 10
+-6 - CST 1930 N 15
+-7 m M%sT 1932 Ap
+-6 - CST 1988
+-6 u C%sT 1989
+-6 m C%sT
+Z America/Montevideo -3:44:51 - LMT 1908 Jun 10
+-3:44:51 - MMT 1920 May
+-4 - %z 1923 O
+-3:30 U %z 1942 D 14
+-3 U %z 1960
+-3 U %z 1968
+-3 U %z 1970
+-3 U %z 1974
+-3 U %z 1974 Mar 10
+-3 U %z 1974 D 22
+-3 U %z
+Z America/New_York -4:56:2 - LMT 1883 N 18 17u
+-5 u E%sT 1920
+-5 NY E%sT 1942
+-5 u E%sT 1946
+-5 NY E%sT 1967
+-5 u E%sT
+Z America/Nome 12:58:22 - LMT 1867 O 19 13:29:35
+-11:1:38 - LMT 1900 Au 20 12
+-11 - NST 1942
+-11 u N%sT 1946
+-11 - NST 1967 Ap
+-11 - BST 1969
+-11 u B%sT 1983 O 30 2
+-9 u Y%sT 1983 N 30
+-9 u AK%sT
+Z America/Noronha -2:9:40 - LMT 1914
+-2 B %z 1990 S 17
+-2 - %z 1999 S 30
+-2 B %z 2000 O 15
+-2 - %z 2001 S 13
+-2 B %z 2002 O
+-2 - %z
+Z America/North_Dakota/Beulah -6:47:7 - LMT 1883 N 18 19u
+-7 u M%sT 2010 N 7 2
+-6 u C%sT
+Z America/North_Dakota/Center -6:45:12 - LMT 1883 N 18 19u
+-7 u M%sT 1992 O 25 2
+-6 u C%sT
+Z America/North_Dakota/New_Salem -6:45:39 - LMT 1883 N 18 19u
+-7 u M%sT 2003 O 26 2
+-6 u C%sT
+Z America/Nuuk -3:26:56 - LMT 1916 Jul 28
+-3 - %z 1980 Ap 6 2
+-3 E %z 2023 Mar 26 1u
+-2 - %z 2023 O 29 1u
+-2 E %z
+Z America/Ojinaga -6:57:40 - LMT 1922 Ja 1 7u
+-7 - MST 1927 Jun 10
+-6 - CST 1930 N 15
+-7 m M%sT 1932 Ap
+-6 - CST 1996
+-6 m C%sT 1998
+-6 - CST 1998 Ap Su>=1 3
+-7 m M%sT 2010
+-7 u M%sT 2022 O 30 2
+-6 - CST 2022 N 30
+-6 u C%sT
+Z America/Panama -5:18:8 - LMT 1890
+-5:19:36 - CMT 1908 Ap 22
+-5 - EST
+Z America/Paramaribo -3:40:40 - LMT 1911
+-3:40:52 - PMT 1935
+-3:40:36 - PMT 1945 O
+-3:30 - %z 1984 O
+-3 - %z
+Z America/Phoenix -7:28:18 - LMT 1883 N 18 19u
+-7 u M%sT 1944 Ja 1 0:1
+-7 - MST 1944 Ap 1 0:1
+-7 u M%sT 1944 O 1 0:1
+-7 - MST 1967
+-7 u M%sT 1968 Mar 21
+-7 - MST
+Z America/Port-au-Prince -4:49:20 - LMT 1890
+-4:49 - PPMT 1917 Ja 24 12
+-5 HT E%sT
+Z America/Porto_Velho -4:15:36 - LMT 1914
+-4 B %z 1988 S 12
+-4 - %z
+Z America/Puerto_Rico -4:24:25 - LMT 1899 Mar 28 12
+-4 - AST 1942 May 3
+-4 u A%sT 1946
+-4 - AST
+Z America/Punta_Arenas -4:43:40 - LMT 1890
+-4:42:45 - SMT 1910 Ja 10
+-5 - %z 1916 Jul
+-4:42:45 - SMT 1918 S 10
+-4 - %z 1919 Jul
+-4:42:45 - SMT 1927 S
+-5 x %z 1932 S
+-4 - %z 1942 Jun
+-5 - %z 1942 Au
+-4 - %z 1946 Au 28 24
+-5 1 %z 1947 Mar 31 24
+-5 - %z 1947 May 21 23
+-4 x %z 2016 D 4
+-3 - %z
+Z America/Rankin_Inlet 0 - -00 1957
+-6 Y C%sT 2000 O 29 2
+-5 - EST 2001 Ap 1 3
+-6 C C%sT
+Z America/Recife -2:19:36 - LMT 1914
+-3 B %z 1990 S 17
+-3 - %z 1999 S 30
+-3 B %z 2000 O 15
+-3 - %z 2001 S 13
+-3 B %z 2002 O
+-3 - %z
+Z America/Regina -6:58:36 - LMT 1905 S
+-7 r M%sT 1960 Ap lastSu 2
+-6 - CST
+Z America/Resolute 0 - -00 1947 Au 31
+-6 Y C%sT 2000 O 29 2
+-5 - EST 2001 Ap 1 3
+-6 C C%sT 2006 O 29 2
+-5 - EST 2007 Mar 11 3
+-6 C C%sT
+Z America/Rio_Branco -4:31:12 - LMT 1914
+-5 B %z 1988 S 12
+-5 - %z 2008 Jun 24
+-4 - %z 2013 N 10
+-5 - %z
+Z America/Santarem -3:38:48 - LMT 1914
+-4 B %z 1988 S 12
+-4 - %z 2008 Jun 24
+-3 - %z
+Z America/Santiago -4:42:45 - LMT 1890
+-4:42:45 - SMT 1910 Ja 10
+-5 - %z 1916 Jul
+-4:42:45 - SMT 1918 S 10
+-4 - %z 1919 Jul
+-4:42:45 - SMT 1927 S
+-5 x %z 1932 S
+-4 - %z 1942 Jun
+-5 - %z 1942 Au
+-4 - %z 1946 Jul 14 24
+-4 1 %z 1946 Au 28 24
+-5 1 %z 1947 Mar 31 24
+-5 - %z 1947 May 21 23
+-4 x %z
+Z America/Santo_Domingo -4:39:36 - LMT 1890
+-4:40 - SDMT 1933 Ap 1 12
+-5 DO %s 1974 O 27
+-4 - AST 2000 O 29 2
+-5 u E%sT 2000 D 3 1
+-4 - AST
+Z America/Sao_Paulo -3:6:28 - LMT 1914
+-3 B %z 1963 O 23
+-3 1 %z 1964
+-3 B %z
+Z America/Scoresbysund -1:27:52 - LMT 1916 Jul 28
+-2 - %z 1980 Ap 6 2
+-2 c %z 1981 Mar 29
+-1 E %z 2024 Mar 31
+-2 E %z
+Z America/Sitka 14:58:47 - LMT 1867 O 19 15:30
+-9:1:13 - LMT 1900 Au 20 12
+-8 - PST 1942
+-8 u P%sT 1946
+-8 - PST 1969
+-8 u P%sT 1983 O 30 2
+-9 u Y%sT 1983 N 30
+-9 u AK%sT
+Z America/St_Johns -3:30:52 - LMT 1884
+-3:30:52 j N%sT 1918
+-3:30:52 C N%sT 1919
+-3:30:52 j N%sT 1935 Mar 30
+-3:30 j N%sT 1942 May 11
+-3:30 C N%sT 1946
+-3:30 j N%sT 2011 N
+-3:30 C N%sT
+Z America/Swift_Current -7:11:20 - LMT 1905 S
+-7 C M%sT 1946 Ap lastSu 2
+-7 r M%sT 1950
+-7 Sw M%sT 1972 Ap lastSu 2
+-6 - CST
+Z America/Tegucigalpa -5:48:52 - LMT 1921 Ap
+-6 HN C%sT
+Z America/Thule -4:35:8 - LMT 1916 Jul 28
+-4 Th A%sT
+Z America/Tijuana -7:48:4 - LMT 1922 Ja 1 7u
+-7 - MST 1924
+-8 - PST 1927 Jun 10
+-7 - MST 1930 N 15
+-8 - PST 1931 Ap
+-8 1 PDT 1931 S 30
+-8 - PST 1942 Ap 24
+-8 1 PWT 1945 Au 14 23u
+-8 1 PPT 1945 N 15
+-8 - PST 1948 Ap 5
+-8 1 PDT 1949 Ja 14
+-8 - PST 1950 May
+-8 1 PDT 1950 S 24
+-8 - PST 1951 Ap 29 2
+-8 1 PDT 1951 S 30 2
+-8 - PST 1952 Ap 27 2
+-8 1 PDT 1952 S 28 2
+-8 - PST 1954
+-8 CA P%sT 1961
+-8 - PST 1976
+-8 u P%sT 1996
+-8 m P%sT 2001
+-8 u P%sT 2002 F 20
+-8 m P%sT 2010
+-8 u P%sT
+Z America/Toronto -5:17:32 - LMT 1895
+-5 C E%sT 1919
+-5 t E%sT 1942 F 9 2s
+-5 C E%sT 1946
+-5 t E%sT 1974
+-5 C E%sT
+Z America/Vancouver -8:12:28 - LMT 1884
+-8 Va P%sT 1987
+-8 C P%sT
+Z America/Whitehorse -9:0:12 - LMT 1900 Au 20
+-9 Y Y%sT 1965
+-9 Yu Y%sT 1966 F 27
+-8 - PST 1980
+-8 C P%sT 2020 N
+-7 - MST
+Z America/Winnipeg -6:28:36 - LMT 1887 Jul 16
+-6 W C%sT 2006
+-6 C C%sT
+Z America/Yakutat 14:41:5 - LMT 1867 O 19 15:12:18
+-9:18:55 - LMT 1900 Au 20 12
+-9 - YST 1942
+-9 u Y%sT 1946
+-9 - YST 1969
+-9 u Y%sT 1983 N 30
+-9 u AK%sT
+Z Antarctica/Casey 0 - -00 1969
+8 - %z 2009 O 18 2
+11 - %z 2010 Mar 5 2
+8 - %z 2011 O 28 2
+11 - %z 2012 F 21 17u
+8 - %z 2016 O 22
+11 - %z 2018 Mar 11 4
+8 - %z 2018 O 7 4
+11 - %z 2019 Mar 17 3
+8 - %z 2019 O 4 3
+11 - %z 2020 Mar 8 3
+8 - %z 2020 O 4 0:1
+11 - %z 2021 Mar 14
+8 - %z 2021 O 3 0:1
+11 - %z 2022 Mar 13
+8 - %z 2022 O 2 0:1
+11 - %z 2023 Mar 9 3
+8 - %z
+Z Antarctica/Davis 0 - -00 1957 Ja 13
+7 - %z 1964 N
+0 - -00 1969 F
+7 - %z 2009 O 18 2
+5 - %z 2010 Mar 10 20u
+7 - %z 2011 O 28 2
+5 - %z 2012 F 21 20u
+7 - %z
+Z Antarctica/Macquarie 0 - -00 1899 N
+10 - AEST 1916 O 1 2
+10 1 AEDT 1917 F
+10 AU AE%sT 1919 Ap 1 0s
+0 - -00 1948 Mar 25
+10 AU AE%sT 1967
+10 AT AE%sT 2010
+10 1 AEDT 2011
+10 AT AE%sT
+Z Antarctica/Mawson 0 - -00 1954 F 13
+6 - %z 2009 O 18 2
+5 - %z
+Z Antarctica/Palmer 0 - -00 1965
+-4 A %z 1969 O 5
+-3 A %z 1982 May
+-4 x %z 2016 D 4
+-3 - %z
+Z Antarctica/Rothera 0 - -00 1976 D
+-3 - %z
+Z Antarctica/Troll 0 - -00 2005 F 12
+0 Tr %s
+Z Antarctica/Vostok 0 - -00 1957 D 16
+7 - %z 1994 F
+0 - -00 1994 N
+7 - %z 2023 D 18 2
+5 - %z
+Z Asia/Almaty 5:7:48 - LMT 1924 May 2
+5 - %z 1930 Jun 21
+6 R %z 1991 Mar 31 2s
+5 R %z 1992 Ja 19 2s
+6 R %z 2004 O 31 2s
+6 - %z 2024 Mar
+5 - %z
+Z Asia/Amman 2:23:44 - LMT 1931
+2 J EE%sT 2022 O 28 0s
+3 - %z
+Z Asia/Anadyr 11:49:56 - LMT 1924 May 2
+12 - %z 1930 Jun 21
+13 R %z 1982 Ap 1 0s
+12 R %z 1991 Mar 31 2s
+11 R %z 1992 Ja 19 2s
+12 R %z 2010 Mar 28 2s
+11 R %z 2011 Mar 27 2s
+12 - %z
+Z Asia/Aqtau 3:21:4 - LMT 1924 May 2
+4 - %z 1930 Jun 21
+5 - %z 1981 O
+6 - %z 1982 Ap
+5 R %z 1991 Mar 31 2s
+4 R %z 1992 Ja 19 2s
+5 R %z 1994 S 25 2s
+4 R %z 2004 O 31 2s
+5 - %z
+Z Asia/Aqtobe 3:48:40 - LMT 1924 May 2
+4 - %z 1930 Jun 21
+5 - %z 1981 Ap
+5 1 %z 1981 O
+6 - %z 1982 Ap
+5 R %z 1991 Mar 31 2s
+4 R %z 1992 Ja 19 2s
+5 R %z 2004 O 31 2s
+5 - %z
+Z Asia/Ashgabat 3:53:32 - LMT 1924 May 2
+4 - %z 1930 Jun 21
+5 R %z 1991 Mar 31 2
+4 R %z 1992 Ja 19 2
+5 - %z
+Z Asia/Atyrau 3:27:44 - LMT 1924 May 2
+3 - %z 1930 Jun 21
+5 - %z 1981 O
+6 - %z 1982 Ap
+5 R %z 1991 Mar 31 2s
+4 R %z 1992 Ja 19 2s
+5 R %z 1999 Mar 28 2s
+4 R %z 2004 O 31 2s
+5 - %z
+Z Asia/Baghdad 2:57:40 - LMT 1890
+2:57:36 - BMT 1918
+3 - %z 1982 May
+3 IQ %z
+Z Asia/Baku 3:19:24 - LMT 1924 May 2
+3 - %z 1957 Mar
+4 R %z 1991 Mar 31 2s
+3 R %z 1992 S lastSu 2s
+4 - %z 1996
+4 E %z 1997
+4 AZ %z
+Z Asia/Bangkok 6:42:4 - LMT 1880
+6:42:4 - BMT 1920 Ap
+7 - %z
+Z Asia/Barnaul 5:35 - LMT 1919 D 10
+6 - %z 1930 Jun 21
+7 R %z 1991 Mar 31 2s
+6 R %z 1992 Ja 19 2s
+7 R %z 1995 May 28
+6 R %z 2011 Mar 27 2s
+7 - %z 2014 O 26 2s
+6 - %z 2016 Mar 27 2s
+7 - %z
+Z Asia/Beirut 2:22 - LMT 1880
+2 l EE%sT
+Z Asia/Bishkek 4:58:24 - LMT 1924 May 2
+5 - %z 1930 Jun 21
+6 R %z 1991 Mar 31 2s
+5 R %z 1991 Au 31 2
+5 KG %z 2005 Au 12
+6 - %z
+Z Asia/Chita 7:33:52 - LMT 1919 D 15
+8 - %z 1930 Jun 21
+9 R %z 1991 Mar 31 2s
+8 R %z 1992 Ja 19 2s
+9 R %z 2011 Mar 27 2s
+10 - %z 2014 O 26 2s
+8 - %z 2016 Mar 27 2
+9 - %z
+Z Asia/Colombo 5:19:24 - LMT 1880
+5:19:32 - MMT 1906
+5:30 - %z 1942 Ja 5
+5:30 0:30 %z 1942 S
+5:30 1 %z 1945 O 16 2
+5:30 - %z 1996 May 25
+6:30 - %z 1996 O 26 0:30
+6 - %z 2006 Ap 15 0:30
+5:30 - %z
+Z Asia/Damascus 2:25:12 - LMT 1920
+2 S EE%sT 2022 O 28
+3 - %z
+Z Asia/Dhaka 6:1:40 - LMT 1890
+5:53:20 - HMT 1941 O
+6:30 - %z 1942 May 15
+5:30 - %z 1942 S
+6:30 - %z 1951 S 30
+6 - %z 2009
+6 BD %z
+Z Asia/Dili 8:22:20 - LMT 1911 D 31 16u
+8 - %z 1942 F 21 23
+9 - %z 1976 May 3
+8 - %z 2000 S 17
+9 - %z
+Z Asia/Dubai 3:41:12 - LMT 1920
+4 - %z
+Z Asia/Dushanbe 4:35:12 - LMT 1924 May 2
+5 - %z 1930 Jun 21
+6 R %z 1991 Mar 31 2s
+5 1 %z 1991 S 9 2s
+5 - %z
+Z Asia/Famagusta 2:15:48 - LMT 1921 N 14
+2 CY EE%sT 1998 S
+2 E EE%sT 2016 S 8
+3 - %z 2017 O 29 1u
+2 E EE%sT
+Z Asia/Gaza 2:17:52 - LMT 1900 O
+2 Z EET/EEST 1948 May 15
+2 K EE%sT 1967 Jun 5
+2 Z I%sT 1996
+2 J EE%sT 1999
+2 P EE%sT 2008 Au 29
+2 - EET 2008 S
+2 P EE%sT 2010
+2 - EET 2010 Mar 27 0:1
+2 P EE%sT 2011 Au
+2 - EET 2012
+2 P EE%sT
+Z Asia/Hebron 2:20:23 - LMT 1900 O
+2 Z EET/EEST 1948 May 15
+2 K EE%sT 1967 Jun 5
+2 Z I%sT 1996
+2 J EE%sT 1999
+2 P EE%sT
+Z Asia/Ho_Chi_Minh 7:6:30 - LMT 1906 Jul
+7:6:30 - PLMT 1911 May
+7 - %z 1942 D 31 23
+8 - %z 1945 Mar 14 23
+9 - %z 1945 S 1 24
+7 - %z 1947 Ap
+8 - %z 1955 Jul 1 1
+7 - %z 1959 D 31 23
+8 - %z 1975 Jun 13
+7 - %z
+Z Asia/Hong_Kong 7:36:42 - LMT 1904 O 29 17u
+8 - HKT 1941 Jun 15 3
+8 1 HKST 1941 O 1 4
+8 0:30 HKWT 1941 D 25
+9 - JST 1945 N 18 2
+8 HK HK%sT
+Z Asia/Hovd 6:6:36 - LMT 1905 Au
+6 - %z 1978
+7 X %z
+Z Asia/Irkutsk 6:57:5 - LMT 1880
+6:57:5 - IMT 1920 Ja 25
+7 - %z 1930 Jun 21
+8 R %z 1991 Mar 31 2s
+7 R %z 1992 Ja 19 2s
+8 R %z 2011 Mar 27 2s
+9 - %z 2014 O 26 2s
+8 - %z
+Z Asia/Jakarta 7:7:12 - LMT 1867 Au 10
+7:7:12 - BMT 1923 D 31 16:40u
+7:20 - %z 1932 N
+7:30 - %z 1942 Mar 23
+9 - %z 1945 S 23
+7:30 - %z 1948 May
+8 - %z 1950 May
+7:30 - %z 1964
+7 - WIB
+Z Asia/Jayapura 9:22:48 - LMT 1932 N
+9 - %z 1944 S
+9:30 - %z 1964
+9 - WIT
+Z Asia/Jerusalem 2:20:54 - LMT 1880
+2:20:40 - JMT 1918
+2 Z I%sT
+Z Asia/Kabul 4:36:48 - LMT 1890
+4 - %z 1945
+4:30 - %z
+Z Asia/Kamchatka 10:34:36 - LMT 1922 N 10
+11 - %z 1930 Jun 21
+12 R %z 1991 Mar 31 2s
+11 R %z 1992 Ja 19 2s
+12 R %z 2010 Mar 28 2s
+11 R %z 2011 Mar 27 2s
+12 - %z
+Z Asia/Karachi 4:28:12 - LMT 1907
+5:30 - %z 1942 S
+5:30 1 %z 1945 O 15
+5:30 - %z 1951 S 30
+5 - %z 1971 Mar 26
+5 PK PK%sT
+Z Asia/Kathmandu 5:41:16 - LMT 1920
+5:30 - %z 1986
+5:45 - %z
+Z Asia/Khandyga 9:2:13 - LMT 1919 D 15
+8 - %z 1930 Jun 21
+9 R %z 1991 Mar 31 2s
+8 R %z 1992 Ja 19 2s
+9 R %z 2004
+10 R %z 2011 Mar 27 2s
+11 - %z 2011 S 13 0s
+10 - %z 2014 O 26 2s
+9 - %z
+Z Asia/Kolkata 5:53:28 - LMT 1854 Jun 28
+5:53:20 - HMT 1870
+5:21:10 - MMT 1906
+5:30 - IST 1941 O
+5:30 1 %z 1942 May 15
+5:30 - IST 1942 S
+5:30 1 %z 1945 O 15
+5:30 - IST
+Z Asia/Krasnoyarsk 6:11:26 - LMT 1920 Ja 6
+6 - %z 1930 Jun 21
+7 R %z 1991 Mar 31 2s
+6 R %z 1992 Ja 19 2s
+7 R %z 2011 Mar 27 2s
+8 - %z 2014 O 26 2s
+7 - %z
+Z Asia/Kuching 7:21:20 - LMT 1926 Mar
+7:30 - %z 1933
+8 NB %z 1942 F 16
+9 - %z 1945 S 12
+8 - %z
+Z Asia/Macau 7:34:10 - LMT 1904 O 30
+8 - CST 1941 D 21 23
+9 _ %z 1945 S 30 24
+8 _ C%sT
+Z Asia/Magadan 10:3:12 - LMT 1924 May 2
+10 - %z 1930 Jun 21
+11 R %z 1991 Mar 31 2s
+10 R %z 1992 Ja 19 2s
+11 R %z 2011 Mar 27 2s
+12 - %z 2014 O 26 2s
+10 - %z 2016 Ap 24 2s
+11 - %z
+Z Asia/Makassar 7:57:36 - LMT 1920
+7:57:36 - MMT 1932 N
+8 - %z 1942 F 9
+9 - %z 1945 S 23
+8 - WITA
+Z Asia/Manila -15:56:8 - LMT 1844 D 31
+8:3:52 - LMT 1899 S 6 4u
+8 PH P%sT 1942 F 11 24
+9 - JST 1945 Mar 4
+8 PH P%sT
+Z Asia/Nicosia 2:13:28 - LMT 1921 N 14
+2 CY EE%sT 1998 S
+2 E EE%sT
+Z Asia/Novokuznetsk 5:48:48 - LMT 1924 May
+6 - %z 1930 Jun 21
+7 R %z 1991 Mar 31 2s
+6 R %z 1992 Ja 19 2s
+7 R %z 2010 Mar 28 2s
+6 R %z 2011 Mar 27 2s
+7 - %z
+Z Asia/Novosibirsk 5:31:40 - LMT 1919 D 14 6
+6 - %z 1930 Jun 21
+7 R %z 1991 Mar 31 2s
+6 R %z 1992 Ja 19 2s
+7 R %z 1993 May 23
+6 R %z 2011 Mar 27 2s
+7 - %z 2014 O 26 2s
+6 - %z 2016 Jul 24 2s
+7 - %z
+Z Asia/Omsk 4:53:30 - LMT 1919 N 14
+5 - %z 1930 Jun 21
+6 R %z 1991 Mar 31 2s
+5 R %z 1992 Ja 19 2s
+6 R %z 2011 Mar 27 2s
+7 - %z 2014 O 26 2s
+6 - %z
+Z Asia/Oral 3:25:24 - LMT 1924 May 2
+3 - %z 1930 Jun 21
+5 - %z 1981 Ap
+5 1 %z 1981 O
+6 - %z 1982 Ap
+5 R %z 1989 Mar 26 2s
+4 R %z 1992 Ja 19 2s
+5 R %z 1992 Mar 29 2s
+4 R %z 2004 O 31 2s
+5 - %z
+Z Asia/Pontianak 7:17:20 - LMT 1908 May
+7:17:20 - PMT 1932 N
+7:30 - %z 1942 Ja 29
+9 - %z 1945 S 23
+7:30 - %z 1948 May
+8 - %z 1950 May
+7:30 - %z 1964
+8 - WITA 1988
+7 - WIB
+Z Asia/Pyongyang 8:23 - LMT 1908 Ap
+8:30 - KST 1912
+9 - JST 1945 Au 24
+9 - KST 2015 Au 15
+8:30 - KST 2018 May 4 23:30
+9 - KST
+Z Asia/Qatar 3:26:8 - LMT 1920
+4 - %z 1972 Jun
+3 - %z
+Z Asia/Qostanay 4:14:28 - LMT 1924 May 2
+4 - %z 1930 Jun 21
+5 - %z 1981 Ap
+5 1 %z 1981 O
+6 - %z 1982 Ap
+5 R %z 1991 Mar 31 2s
+4 R %z 1992 Ja 19 2s
+5 R %z 2004 O 31 2s
+6 - %z 2024 Mar
+5 - %z
+Z Asia/Qyzylorda 4:21:52 - LMT 1924 May 2
+4 - %z 1930 Jun 21
+5 - %z 1981 Ap
+5 1 %z 1981 O
+6 - %z 1982 Ap
+5 R %z 1991 Mar 31 2s
+4 R %z 1991 S 29 2s
+5 R %z 1992 Ja 19 2s
+6 R %z 1992 Mar 29 2s
+5 R %z 2004 O 31 2s
+6 - %z 2018 D 21
+5 - %z
+Z Asia/Riyadh 3:6:52 - LMT 1947 Mar 14
+3 - %z
+Z Asia/Sakhalin 9:30:48 - LMT 1905 Au 23
+9 - %z 1945 Au 25
+11 R %z 1991 Mar 31 2s
+10 R %z 1992 Ja 19 2s
+11 R %z 1997 Mar lastSu 2s
+10 R %z 2011 Mar 27 2s
+11 - %z 2014 O 26 2s
+10 - %z 2016 Mar 27 2s
+11 - %z
+Z Asia/Samarkand 4:27:53 - LMT 1924 May 2
+4 - %z 1930 Jun 21
+5 - %z 1981 Ap
+5 1 %z 1981 O
+6 - %z 1982 Ap
+5 R %z 1992
+5 - %z
+Z Asia/Seoul 8:27:52 - LMT 1908 Ap
+8:30 - KST 1912
+9 - JST 1945 S 8
+9 KR K%sT 1954 Mar 21
+8:30 KR K%sT 1961 Au 10
+9 KR K%sT
+Z Asia/Shanghai 8:5:43 - LMT 1901
+8 Sh C%sT 1949 May 28
+8 CN C%sT
+Z Asia/Singapore 6:55:25 - LMT 1901
+6:55:25 - SMT 1905 Jun
+7 - %z 1933
+7 0:20 %z 1936
+7:20 - %z 1941 S
+7:30 - %z 1942 F 16
+9 - %z 1945 S 12
+7:30 - %z 1981 D 31 16u
+8 - %z
+Z Asia/Srednekolymsk 10:14:52 - LMT 1924 May 2
+10 - %z 1930 Jun 21
+11 R %z 1991 Mar 31 2s
+10 R %z 1992 Ja 19 2s
+11 R %z 2011 Mar 27 2s
+12 - %z 2014 O 26 2s
+11 - %z
+Z Asia/Taipei 8:6 - LMT 1896
+8 - CST 1937 O
+9 - JST 1945 S 21 1
+8 f C%sT
+Z Asia/Tashkent 4:37:11 - LMT 1924 May 2
+5 - %z 1930 Jun 21
+6 R %z 1991 Mar 31 2
+5 R %z 1992
+5 - %z
+Z Asia/Tbilisi 2:59:11 - LMT 1880
+2:59:11 - TBMT 1924 May 2
+3 - %z 1957 Mar
+4 R %z 1991 Mar 31 2s
+3 R %z 1992
+3 e %z 1994 S lastSu
+4 e %z 1996 O lastSu
+4 1 %z 1997 Mar lastSu
+4 e %z 2004 Jun 27
+3 R %z 2005 Mar lastSu 2
+4 - %z
+Z Asia/Tehran 3:25:44 - LMT 1916
+3:25:44 - TMT 1935 Jun 13
+3:30 i %z 1977 O 20 24
+4 i %z 1979
+3:30 i %z
+Z Asia/Thimphu 5:58:36 - LMT 1947 Au 15
+5:30 - %z 1987 O
+6 - %z
+Z Asia/Tokyo 9:18:59 - LMT 1887 D 31 15u
+9 JP J%sT
+Z Asia/Tomsk 5:39:51 - LMT 1919 D 22
+6 - %z 1930 Jun 21
+7 R %z 1991 Mar 31 2s
+6 R %z 1992 Ja 19 2s
+7 R %z 2002 May 1 3
+6 R %z 2011 Mar 27 2s
+7 - %z 2014 O 26 2s
+6 - %z 2016 May 29 2s
+7 - %z
+Z Asia/Ulaanbaatar 7:7:32 - LMT 1905 Au
+7 - %z 1978
+8 X %z
+Z Asia/Urumqi 5:50:20 - LMT 1928
+6 - %z
+Z Asia/Ust-Nera 9:32:54 - LMT 1919 D 15
+8 - %z 1930 Jun 21
+9 R %z 1981 Ap
+11 R %z 1991 Mar 31 2s
+10 R %z 1992 Ja 19 2s
+11 R %z 2011 Mar 27 2s
+12 - %z 2011 S 13 0s
+11 - %z 2014 O 26 2s
+10 - %z
+Z Asia/Vladivostok 8:47:31 - LMT 1922 N 15
+9 - %z 1930 Jun 21
+10 R %z 1991 Mar 31 2s
+9 R %z 1992 Ja 19 2s
+10 R %z 2011 Mar 27 2s
+11 - %z 2014 O 26 2s
+10 - %z
+Z Asia/Yakutsk 8:38:58 - LMT 1919 D 15
+8 - %z 1930 Jun 21
+9 R %z 1991 Mar 31 2s
+8 R %z 1992 Ja 19 2s
+9 R %z 2011 Mar 27 2s
+10 - %z 2014 O 26 2s
+9 - %z
+Z Asia/Yangon 6:24:47 - LMT 1880
+6:24:47 - RMT 1920
+6:30 - %z 1942 May
+9 - %z 1945 May 3
+6:30 - %z
+Z Asia/Yekaterinburg 4:2:33 - LMT 1916 Jul 3
+3:45:5 - PMT 1919 Jul 15 4
+4 - %z 1930 Jun 21
+5 R %z 1991 Mar 31 2s
+4 R %z 1992 Ja 19 2s
+5 R %z 2011 Mar 27 2s
+6 - %z 2014 O 26 2s
+5 - %z
+Z Asia/Yerevan 2:58 - LMT 1924 May 2
+3 - %z 1957 Mar
+4 R %z 1991 Mar 31 2s
+3 R %z 1995 S 24 2s
+4 - %z 1997
+4 R %z 2011
+4 AM %z
+Z Atlantic/Azores -1:42:40 - LMT 1884
+-1:54:32 - HMT 1912 Ja 1 2u
+-2 p %z 1966 O 2 2s
+-1 - %z 1982 Mar 28 0s
+-1 p %z 1986
+-1 E %z 1992 D 27 1s
+0 E WE%sT 1993 Jun 17 1u
+-1 E %z
+Z Atlantic/Bermuda -4:19:18 - LMT 1890
+-4:19:18 Be BMT/BST 1930 Ja 1 2
+-4 Be A%sT 1974 Ap 28 2
+-4 C A%sT 1976
+-4 u A%sT
+Z Atlantic/Canary -1:1:36 - LMT 1922 Mar
+-1 - %z 1946 S 30 1
+0 - WET 1980 Ap 6 0s
+0 1 WEST 1980 S 28 1u
+0 E WE%sT
+Z Atlantic/Cape_Verde -1:34:4 - LMT 1912 Ja 1 2u
+-2 - %z 1942 S
+-2 1 %z 1945 O 15
+-2 - %z 1975 N 25 2
+-1 - %z
+Z Atlantic/Faroe -0:27:4 - LMT 1908 Ja 11
+0 - WET 1981
+0 E WE%sT
+Z Atlantic/Madeira -1:7:36 - LMT 1884
+-1:7:36 - FMT 1912 Ja 1 1u
+-1 p %z 1966 O 2 2s
+0 - WET 1982 Ap 4
+0 p WE%sT 1986 Jul 31
+0 E WE%sT
+Z Atlantic/South_Georgia -2:26:8 - LMT 1890
+-2 - %z
+Z Atlantic/Stanley -3:51:24 - LMT 1890
+-3:51:24 - SMT 1912 Mar 12
+-4 FK %z 1983 May
+-3 FK %z 1985 S 15
+-4 FK %z 2010 S 5 2
+-3 - %z
+Z Australia/Adelaide 9:14:20 - LMT 1895 F
+9 - ACST 1899 May
+9:30 AU AC%sT 1971
+9:30 AS AC%sT
+Z Australia/Brisbane 10:12:8 - LMT 1895
+10 AU AE%sT 1971
+10 AQ AE%sT
+Z Australia/Broken_Hill 9:25:48 - LMT 1895 F
+10 - AEST 1896 Au 23
+9 - ACST 1899 May
+9:30 AU AC%sT 1971
+9:30 AN AC%sT 2000
+9:30 AS AC%sT
+Z Australia/Darwin 8:43:20 - LMT 1895 F
+9 - ACST 1899 May
+9:30 AU AC%sT
+Z Australia/Eucla 8:35:28 - LMT 1895 D
+8:45 AU %z 1943 Jul
+8:45 AW %z
+Z Australia/Hobart 9:49:16 - LMT 1895 S
+10 AT AE%sT 1919 O 24
+10 AU AE%sT 1967
+10 AT AE%sT
+Z Australia/Lindeman 9:55:56 - LMT 1895
+10 AU AE%sT 1971
+10 AQ AE%sT 1992 Jul
+10 Ho AE%sT
+Z Australia/Lord_Howe 10:36:20 - LMT 1895 F
+10 - AEST 1981 Mar
+10:30 LH %z 1985 Jul
+10:30 LH %z
+Z Australia/Melbourne 9:39:52 - LMT 1895 F
+10 AU AE%sT 1971
+10 AV AE%sT
+Z Australia/Perth 7:43:24 - LMT 1895 D
+8 AU AW%sT 1943 Jul
+8 AW AW%sT
+Z Australia/Sydney 10:4:52 - LMT 1895 F
+10 AU AE%sT 1971
+10 AN AE%sT
+Z Etc/GMT 0 - GMT
+Z Etc/GMT+1 -1 - %z
+Z Etc/GMT+10 -10 - %z
+Z Etc/GMT+11 -11 - %z
+Z Etc/GMT+12 -12 - %z
+Z Etc/GMT+2 -2 - %z
+Z Etc/GMT+3 -3 - %z
+Z Etc/GMT+4 -4 - %z
+Z Etc/GMT+5 -5 - %z
+Z Etc/GMT+6 -6 - %z
+Z Etc/GMT+7 -7 - %z
+Z Etc/GMT+8 -8 - %z
+Z Etc/GMT+9 -9 - %z
+Z Etc/GMT-1 1 - %z
+Z Etc/GMT-10 10 - %z
+Z Etc/GMT-11 11 - %z
+Z Etc/GMT-12 12 - %z
+Z Etc/GMT-13 13 - %z
+Z Etc/GMT-14 14 - %z
+Z Etc/GMT-2 2 - %z
+Z Etc/GMT-3 3 - %z
+Z Etc/GMT-4 4 - %z
+Z Etc/GMT-5 5 - %z
+Z Etc/GMT-6 6 - %z
+Z Etc/GMT-7 7 - %z
+Z Etc/GMT-8 8 - %z
+Z Etc/GMT-9 9 - %z
+Z Etc/UTC 0 - UTC
+Z Europe/Andorra 0:6:4 - LMT 1901
+0 - WET 1946 S 30
+1 - CET 1985 Mar 31 2
+1 E CE%sT
+Z Europe/Astrakhan 3:12:12 - LMT 1924 May
+3 - %z 1930 Jun 21
+4 R %z 1989 Mar 26 2s
+3 R %z 1991 Mar 31 2s
+4 - %z 1992 Mar 29 2s
+3 R %z 2011 Mar 27 2s
+4 - %z 2014 O 26 2s
+3 - %z 2016 Mar 27 2s
+4 - %z
+Z Europe/Athens 1:34:52 - LMT 1895 S 14
+1:34:52 - AMT 1916 Jul 28 0:1
+2 g EE%sT 1941 Ap 30
+1 g CE%sT 1944 Ap 4
+2 g EE%sT 1981
+2 E EE%sT
+Z Europe/Belgrade 1:22 - LMT 1884
+1 - CET 1941 Ap 18 23
+1 c CE%sT 1945
+1 - CET 1945 May 8 2s
+1 1 CEST 1945 S 16 2s
+1 - CET 1982 N 27
+1 E CE%sT
+Z Europe/Berlin 0:53:28 - LMT 1893 Ap
+1 c CE%sT 1945 May 24 2
+1 So CE%sT 1946
+1 DE CE%sT 1980
+1 E CE%sT
+Z Europe/Brussels 0:17:30 - LMT 1880
+0:17:30 - BMT 1892 May 1 0:17:30
+0 - WET 1914 N 8
+1 - CET 1916 May
+1 c CE%sT 1918 N 11 11u
+0 b WE%sT 1940 May 20 2s
+1 c CE%sT 1944 S 3
+1 b CE%sT 1977
+1 E CE%sT
+Z Europe/Bucharest 1:44:24 - LMT 1891 O
+1:44:24 - BMT 1931 Jul 24
+2 z EE%sT 1981 Mar 29 2s
+2 c EE%sT 1991
+2 z EE%sT 1994
+2 e EE%sT 1997
+2 E EE%sT
+Z Europe/Budapest 1:16:20 - LMT 1890 N
+1 c CE%sT 1918
+1 h CE%sT 1941 Ap 7 23
+1 c CE%sT 1945
+1 h CE%sT 1984
+1 E CE%sT
+Z Europe/Chisinau 1:55:20 - LMT 1880
+1:55 - CMT 1918 F 15
+1:44:24 - BMT 1931 Jul 24
+2 z EE%sT 1940 Au 15
+2 1 EEST 1941 Jul 17
+1 c CE%sT 1944 Au 24
+3 R MSK/MSD 1990 May 6 2
+2 R EE%sT 1992
+2 e EE%sT 1997
+2 MD EE%sT
+Z Europe/Dublin -0:25:21 - LMT 1880 Au 2
+-0:25:21 - DMT 1916 May 21 2s
+-0:25:21 1 IST 1916 O 1 2s
+0 G %s 1921 D 6
+0 G GMT/IST 1940 F 25 2s
+0 1 IST 1946 O 6 2s
+0 - GMT 1947 Mar 16 2s
+0 1 IST 1947 N 2 2s
+0 - GMT 1948 Ap 18 2s
+0 G GMT/IST 1968 O 27
+1 IE IST/GMT
+Z Europe/Gibraltar -0:21:24 - LMT 1880 Au 2
+0 G %s 1957 Ap 14 2
+1 - CET 1982
+1 E CE%sT
+Z Europe/Helsinki 1:39:49 - LMT 1878 May 31
+1:39:49 - HMT 1921 May
+2 FI EE%sT 1983
+2 E EE%sT
+Z Europe/Istanbul 1:55:52 - LMT 1880
+1:56:56 - IMT 1910 O
+2 T EE%sT 1978 Jun 29
+3 T %z 1984 N 1 2
+2 T EE%sT 2007
+2 E EE%sT 2011 Mar 27 1u
+2 - EET 2011 Mar 28 1u
+2 E EE%sT 2014 Mar 30 1u
+2 - EET 2014 Mar 31 1u
+2 E EE%sT 2015 O 25 1u
+2 1 EEST 2015 N 8 1u
+2 E EE%sT 2016 S 7
+3 - %z
+Z Europe/Kaliningrad 1:22 - LMT 1893 Ap
+1 c CE%sT 1945 Ap 10
+2 O EE%sT 1946 Ap 7
+3 R MSK/MSD 1989 Mar 26 2s
+2 R EE%sT 2011 Mar 27 2s
+3 - %z 2014 O 26 2s
+2 - EET
+Z Europe/Kirov 3:18:48 - LMT 1919 Jul 1 0u
+3 - %z 1930 Jun 21
+4 R %z 1989 Mar 26 2s
+3 R MSK/MSD 1991 Mar 31 2s
+4 - %z 1992 Mar 29 2s
+3 R MSK/MSD 2011 Mar 27 2s
+4 - MSK 2014 O 26 2s
+3 - MSK
+Z Europe/Kyiv 2:2:4 - LMT 1880
+2:2:4 - KMT 1924 May 2
+2 - EET 1930 Jun 21
+3 - MSK 1941 S 20
+1 c CE%sT 1943 N 6
+3 R MSK/MSD 1990 Jul 1 2
+2 1 EEST 1991 S 29 3
+2 c EE%sT 1996 May 13
+2 E EE%sT
+Z Europe/Lisbon -0:36:45 - LMT 1884
+-0:36:45 - LMT 1912 Ja 1 0u
+0 p WE%sT 1966 O 2 2s
+1 - CET 1976 S 26 1
+0 p WE%sT 1986
+0 E WE%sT 1992 S 27 1u
+1 E CE%sT 1996 Mar 31 1u
+0 E WE%sT
+Z Europe/London -0:1:15 - LMT 1847 D
+0 G %s 1968 O 27
+1 - BST 1971 O 31 2u
+0 G %s 1996
+0 E GMT/BST
+Z Europe/Madrid -0:14:44 - LMT 1901 Ja 1 0u
+0 s WE%sT 1940 Mar 16 23
+1 s CE%sT 1979
+1 E CE%sT
+Z Europe/Malta 0:58:4 - LMT 1893 N 2
+1 I CE%sT 1973 Mar 31
+1 MT CE%sT 1981
+1 E CE%sT
+Z Europe/Minsk 1:50:16 - LMT 1880
+1:50 - MMT 1924 May 2
+2 - EET 1930 Jun 21
+3 - MSK 1941 Jun 28
+1 c CE%sT 1944 Jul 3
+3 R MSK/MSD 1990
+3 - MSK 1991 Mar 31 2s
+2 R EE%sT 2011 Mar 27 2s
+3 - %z
+Z Europe/Moscow 2:30:17 - LMT 1880
+2:30:17 - MMT 1916 Jul 3
+2:31:19 R %s 1919 Jul 1 0u
+3 R %s 1921 O
+3 R MSK/MSD 1922 O
+2 - EET 1930 Jun 21
+3 R MSK/MSD 1991 Mar 31 2s
+2 R EE%sT 1992 Ja 19 2s
+3 R MSK/MSD 2011 Mar 27 2s
+4 - MSK 2014 O 26 2s
+3 - MSK
+Z Europe/Paris 0:9:21 - LMT 1891 Mar 16
+0:9:21 - PMT 1911 Mar 11
+0 F WE%sT 1940 Jun 14 23
+1 c CE%sT 1944 Au 25
+0 F WE%sT 1945 S 16 3
+1 F CE%sT 1977
+1 E CE%sT
+Z Europe/Prague 0:57:44 - LMT 1850
+0:57:44 - PMT 1891 O
+1 c CE%sT 1945 May 9
+1 CZ CE%sT 1946 D 1 3
+1 -1 GMT 1947 F 23 2
+1 CZ CE%sT 1979
+1 E CE%sT
+Z Europe/Riga 1:36:34 - LMT 1880
+1:36:34 - RMT 1918 Ap 15 2
+1:36:34 1 LST 1918 S 16 3
+1:36:34 - RMT 1919 Ap 1 2
+1:36:34 1 LST 1919 May 22 3
+1:36:34 - RMT 1926 May 11
+2 - EET 1940 Au 5
+3 - MSK 1941 Jul
+1 c CE%sT 1944 O 13
+3 R MSK/MSD 1989 Mar lastSu 2s
+2 1 EEST 1989 S lastSu 2s
+2 LV EE%sT 1997 Ja 21
+2 E EE%sT 2000 F 29
+2 - EET 2001 Ja 2
+2 E EE%sT
+Z Europe/Rome 0:49:56 - LMT 1866 D 12
+0:49:56 - RMT 1893 O 31 23u
+1 I CE%sT 1943 S 10
+1 c CE%sT 1944 Jun 4
+1 I CE%sT 1980
+1 E CE%sT
+Z Europe/Samara 3:20:20 - LMT 1919 Jul 1 0u
+3 - %z 1930 Jun 21
+4 - %z 1935 Ja 27
+4 R %z 1989 Mar 26 2s
+3 R %z 1991 Mar 31 2s
+2 R %z 1991 S 29 2s
+3 - %z 1991 O 20 3
+4 R %z 2010 Mar 28 2s
+3 R %z 2011 Mar 27 2s
+4 - %z
+Z Europe/Saratov 3:4:18 - LMT 1919 Jul 1 0u
+3 - %z 1930 Jun 21
+4 R %z 1988 Mar 27 2s
+3 R %z 1991 Mar 31 2s
+4 - %z 1992 Mar 29 2s
+3 R %z 2011 Mar 27 2s
+4 - %z 2014 O 26 2s
+3 - %z 2016 D 4 2s
+4 - %z
+Z Europe/Simferopol 2:16:24 - LMT 1880
+2:16 - SMT 1924 May 2
+2 - EET 1930 Jun 21
+3 - MSK 1941 N
+1 c CE%sT 1944 Ap 13
+3 R MSK/MSD 1990
+3 - MSK 1990 Jul 1 2
+2 - EET 1992 Mar 20
+2 c EE%sT 1994 May
+3 c MSK/MSD 1996 Mar 31 0s
+3 1 MSD 1996 O 27 3s
+3 - MSK 1997 Mar lastSu 1u
+2 E EE%sT 2014 Mar 30 2
+4 - MSK 2014 O 26 2s
+3 - MSK
+Z Europe/Sofia 1:33:16 - LMT 1880
+1:56:56 - IMT 1894 N 30
+2 - EET 1942 N 2 3
+1 c CE%sT 1945
+1 - CET 1945 Ap 2 3
+2 - EET 1979 Mar 31 23
+2 BG EE%sT 1982 S 26 3
+2 c EE%sT 1991
+2 e EE%sT 1997
+2 E EE%sT
+Z Europe/Tallinn 1:39 - LMT 1880
+1:39 - TMT 1918 F
+1 c CE%sT 1919 Jul
+1:39 - TMT 1921 May
+2 - EET 1940 Au 6
+3 - MSK 1941 S 15
+1 c CE%sT 1944 S 22
+3 R MSK/MSD 1989 Mar 26 2s
+2 1 EEST 1989 S 24 2s
+2 c EE%sT 1998 S 22
+2 E EE%sT 1999 O 31 4
+2 - EET 2002 F 21
+2 E EE%sT
+Z Europe/Tirane 1:19:20 - LMT 1914
+1 - CET 1940 Jun 16
+1 q CE%sT 1984 Jul
+1 E CE%sT
+Z Europe/Ulyanovsk 3:13:36 - LMT 1919 Jul 1 0u
+3 - %z 1930 Jun 21
+4 R %z 1989 Mar 26 2s
+3 R %z 1991 Mar 31 2s
+2 R %z 1992 Ja 19 2s
+3 R %z 2011 Mar 27 2s
+4 - %z 2014 O 26 2s
+3 - %z 2016 Mar 27 2s
+4 - %z
+Z Europe/Vienna 1:5:21 - LMT 1893 Ap
+1 c CE%sT 1920
+1 a CE%sT 1940 Ap 1 2s
+1 c CE%sT 1945 Ap 2 2s
+1 1 CEST 1945 Ap 12 2s
+1 - CET 1946
+1 a CE%sT 1981
+1 E CE%sT
+Z Europe/Vilnius 1:41:16 - LMT 1880
+1:24 - WMT 1917
+1:35:36 - KMT 1919 O 10
+1 - CET 1920 Jul 12
+2 - EET 1920 O 9
+1 - CET 1940 Au 3
+3 - MSK 1941 Jun 24
+1 c CE%sT 1944 Au
+3 R MSK/MSD 1989 Mar 26 2s
+2 R EE%sT 1991 S 29 2s
+2 c EE%sT 1998
+2 - EET 1998 Mar 29 1u
+1 E CE%sT 1999 O 31 1u
+2 - EET 2003
+2 E EE%sT
+Z Europe/Volgograd 2:57:40 - LMT 1920 Ja 3
+3 - %z 1930 Jun 21
+4 - %z 1961 N 11
+4 R %z 1988 Mar 27 2s
+3 R MSK/MSD 1991 Mar 31 2s
+4 - %z 1992 Mar 29 2s
+3 R MSK/MSD 2011 Mar 27 2s
+4 - MSK 2014 O 26 2s
+3 - MSK 2018 O 28 2s
+4 - %z 2020 D 27 2s
+3 - MSK
+Z Europe/Warsaw 1:24 - LMT 1880
+1:24 - WMT 1915 Au 5
+1 c CE%sT 1918 S 16 3
+2 O EE%sT 1922 Jun
+1 O CE%sT 1940 Jun 23 2
+1 c CE%sT 1944 O
+1 O CE%sT 1977
+1 W- CE%sT 1988
+1 E CE%sT
+Z Europe/Zurich 0:34:8 - LMT 1853 Jul 16
+0:29:46 - BMT 1894 Jun
+1 CH CE%sT 1981
+1 E CE%sT
+Z Factory 0 - -00
+Z Indian/Chagos 4:49:40 - LMT 1907
+5 - %z 1996
+6 - %z
+Z Indian/Maldives 4:54 - LMT 1880
+4:54 - MMT 1960
+5 - %z
+Z Indian/Mauritius 3:50 - LMT 1907
+4 MU %z
+Z Pacific/Apia 12:33:4 - LMT 1892 Jul 5
+-11:26:56 - LMT 1911
+-11:30 - %z 1950
+-11 WS %z 2011 D 29 24
+13 WS %z
+Z Pacific/Auckland 11:39:4 - LMT 1868 N 2
+11:30 NZ NZ%sT 1946
+12 NZ NZ%sT
+Z Pacific/Bougainville 10:22:16 - LMT 1880
+9:48:32 - PMMT 1895
+10 - %z 1942 Jul
+9 - %z 1945 Au 21
+10 - %z 2014 D 28 2
+11 - %z
+Z Pacific/Chatham 12:13:48 - LMT 1868 N 2
+12:15 - %z 1946
+12:45 k %z
+Z Pacific/Easter -7:17:28 - LMT 1890
+-7:17:28 - EMT 1932 S
+-7 x %z 1982 Mar 14 3u
+-6 x %z
+Z Pacific/Efate 11:13:16 - LMT 1912 Ja 13
+11 VU %z
+Z Pacific/Fakaofo -11:24:56 - LMT 1901
+-11 - %z 2011 D 30
+13 - %z
+Z Pacific/Fiji 11:55:44 - LMT 1915 O 26
+12 FJ %z
+Z Pacific/Galapagos -5:58:24 - LMT 1931
+-5 - %z 1986
+-6 EC %z
+Z Pacific/Gambier -8:59:48 - LMT 1912 O
+-9 - %z
+Z Pacific/Guadalcanal 10:39:48 - LMT 1912 O
+11 - %z
+Z Pacific/Guam -14:21 - LMT 1844 D 31
+9:39 - LMT 1901
+10 - GST 1941 D 10
+9 - %z 1944 Jul 31
+10 Gu G%sT 2000 D 23
+10 - ChST
+Z Pacific/Honolulu -10:31:26 - LMT 1896 Ja 13 12
+-10:30 - HST 1933 Ap 30 2
+-10:30 1 HDT 1933 May 21 12
+-10:30 u H%sT 1947 Jun 8 2
+-10 - HST
+Z Pacific/Kanton 0 - -00 1937 Au 31
+-12 - %z 1979 O
+-11 - %z 1994 D 31
+13 - %z
+Z Pacific/Kiritimati -10:29:20 - LMT 1901
+-10:40 - %z 1979 O
+-10 - %z 1994 D 31
+14 - %z
+Z Pacific/Kosrae -13:8:4 - LMT 1844 D 31
+10:51:56 - LMT 1901
+11 - %z 1914 O
+9 - %z 1919 F
+11 - %z 1937
+10 - %z 1941 Ap
+9 - %z 1945 Au
+11 - %z 1969 O
+12 - %z 1999
+11 - %z
+Z Pacific/Kwajalein 11:9:20 - LMT 1901
+11 - %z 1937
+10 - %z 1941 Ap
+9 - %z 1944 F 6
+11 - %z 1969 O
+-12 - %z 1993 Au 20 24
+12 - %z
+Z Pacific/Marquesas -9:18 - LMT 1912 O
+-9:30 - %z
+Z Pacific/Nauru 11:7:40 - LMT 1921 Ja 15
+11:30 - %z 1942 Au 29
+9 - %z 1945 S 8
+11:30 - %z 1979 F 10 2
+12 - %z
+Z Pacific/Niue -11:19:40 - LMT 1952 O 16
+-11:20 - %z 1964 Jul
+-11 - %z
+Z Pacific/Norfolk 11:11:52 - LMT 1901
+11:12 - %z 1951
+11:30 - %z 1974 O 27 2s
+11:30 1 %z 1975 Mar 2 2s
+11:30 - %z 2015 O 4 2s
+11 - %z 2019 Jul
+11 AN %z
+Z Pacific/Noumea 11:5:48 - LMT 1912 Ja 13
+11 NC %z
+Z Pacific/Pago_Pago 12:37:12 - LMT 1892 Jul 5
+-11:22:48 - LMT 1911
+-11 - SST
+Z Pacific/Palau -15:2:4 - LMT 1844 D 31
+8:57:56 - LMT 1901
+9 - %z
+Z Pacific/Pitcairn -8:40:20 - LMT 1901
+-8:30 - %z 1998 Ap 27
+-8 - %z
+Z Pacific/Port_Moresby 9:48:40 - LMT 1880
+9:48:32 - PMMT 1895
+10 - %z
+Z Pacific/Rarotonga 13:20:56 - LMT 1899 D 26
+-10:39:4 - LMT 1952 O 16
+-10:30 - %z 1978 N 12
+-10 CK %z
+Z Pacific/Tahiti -9:58:16 - LMT 1912 O
+-10 - %z
+Z Pacific/Tarawa 11:32:4 - LMT 1901
+12 - %z
+Z Pacific/Tongatapu 12:19:12 - LMT 1945 S 10
+12:20 - %z 1961
+13 - %z 1999
+13 TO %z
+L Etc/GMT GMT
+L Australia/Sydney Australia/ACT
+L Australia/Lord_Howe Australia/LHI
+L Australia/Sydney Australia/NSW
+L Australia/Darwin Australia/North
+L Australia/Brisbane Australia/Queensland
+L Australia/Adelaide Australia/South
+L Australia/Hobart Australia/Tasmania
+L Australia/Melbourne Australia/Victoria
+L Australia/Perth Australia/West
+L Australia/Broken_Hill Australia/Yancowinna
+L America/Rio_Branco Brazil/Acre
+L America/Noronha Brazil/DeNoronha
+L America/Sao_Paulo Brazil/East
+L America/Manaus Brazil/West
+L Europe/Brussels CET
+L America/Chicago CST6CDT
+L America/Halifax Canada/Atlantic
+L America/Winnipeg Canada/Central
+L America/Toronto Canada/Eastern
+L America/Edmonton Canada/Mountain
+L America/St_Johns Canada/Newfoundland
+L America/Vancouver Canada/Pacific
+L America/Regina Canada/Saskatchewan
+L America/Whitehorse Canada/Yukon
+L America/Santiago Chile/Continental
+L Pacific/Easter Chile/EasterIsland
+L America/Havana Cuba
+L Europe/Athens EET
+L America/Panama EST
+L America/New_York EST5EDT
+L Africa/Cairo Egypt
+L Europe/Dublin Eire
+L Etc/GMT Etc/GMT+0
+L Etc/GMT Etc/GMT-0
+L Etc/GMT Etc/GMT0
+L Etc/GMT Etc/Greenwich
+L Etc/UTC Etc/UCT
+L Etc/UTC Etc/Universal
+L Etc/UTC Etc/Zulu
+L Europe/London GB
+L Europe/London GB-Eire
+L Etc/GMT GMT+0
+L Etc/GMT GMT-0
+L Etc/GMT GMT0
+L Etc/GMT Greenwich
+L Asia/Hong_Kong Hongkong
+L Africa/Abidjan Iceland
+L Asia/Tehran Iran
+L Asia/Jerusalem Israel
+L America/Jamaica Jamaica
+L Asia/Tokyo Japan
+L Pacific/Kwajalein Kwajalein
+L Africa/Tripoli Libya
+L Europe/Brussels MET
+L America/Phoenix MST
+L America/Denver MST7MDT
+L America/Tijuana Mexico/BajaNorte
+L America/Mazatlan Mexico/BajaSur
+L America/Mexico_City Mexico/General
+L Pacific/Auckland NZ
+L Pacific/Chatham NZ-CHAT
+L America/Denver Navajo
+L Asia/Shanghai PRC
+L Europe/Warsaw Poland
+L Europe/Lisbon Portugal
+L Asia/Taipei ROC
+L Asia/Seoul ROK
+L Asia/Singapore Singapore
+L Europe/Istanbul Turkey
+L Etc/UTC UCT
+L America/Anchorage US/Alaska
+L America/Adak US/Aleutian
+L America/Phoenix US/Arizona
+L America/Chicago US/Central
+L America/Indiana/Indianapolis US/East-Indiana
+L America/New_York US/Eastern
+L Pacific/Honolulu US/Hawaii
+L America/Indiana/Knox US/Indiana-Starke
+L America/Detroit US/Michigan
+L America/Denver US/Mountain
+L America/Los_Angeles US/Pacific
+L Pacific/Pago_Pago US/Samoa
+L Etc/UTC UTC
+L Etc/UTC Universal
+L Europe/Moscow W-SU
+L Etc/UTC Zulu
+L America/Argentina/Buenos_Aires America/Buenos_Aires
+L America/Argentina/Catamarca America/Catamarca
+L America/Argentina/Cordoba America/Cordoba
+L America/Indiana/Indianapolis America/Indianapolis
+L America/Argentina/Jujuy America/Jujuy
+L America/Indiana/Knox America/Knox_IN
+L America/Kentucky/Louisville America/Louisville
+L America/Argentina/Mendoza America/Mendoza
+L America/Puerto_Rico America/Virgin
+L Pacific/Pago_Pago Pacific/Samoa
+L Africa/Abidjan Africa/Accra
+L Africa/Nairobi Africa/Addis_Ababa
+L Africa/Nairobi Africa/Asmara
+L Africa/Abidjan Africa/Bamako
+L Africa/Lagos Africa/Bangui
+L Africa/Abidjan Africa/Banjul
+L Africa/Maputo Africa/Blantyre
+L Africa/Lagos Africa/Brazzaville
+L Africa/Maputo Africa/Bujumbura
+L Africa/Abidjan Africa/Conakry
+L Africa/Abidjan Africa/Dakar
+L Africa/Nairobi Africa/Dar_es_Salaam
+L Africa/Nairobi Africa/Djibouti
+L Africa/Lagos Africa/Douala
+L Africa/Abidjan Africa/Freetown
+L Africa/Maputo Africa/Gaborone
+L Africa/Maputo Africa/Harare
+L Africa/Nairobi Africa/Kampala
+L Africa/Maputo Africa/Kigali
+L Africa/Lagos Africa/Kinshasa
+L Africa/Lagos Africa/Libreville
+L Africa/Abidjan Africa/Lome
+L Africa/Lagos Africa/Luanda
+L Africa/Maputo Africa/Lubumbashi
+L Africa/Maputo Africa/Lusaka
+L Africa/Lagos Africa/Malabo
+L Africa/Johannesburg Africa/Maseru
+L Africa/Johannesburg Africa/Mbabane
+L Africa/Nairobi Africa/Mogadishu
+L Africa/Lagos Africa/Niamey
+L Africa/Abidjan Africa/Nouakchott
+L Africa/Abidjan Africa/Ouagadougou
+L Africa/Lagos Africa/Porto-Novo
+L America/Puerto_Rico America/Anguilla
+L America/Puerto_Rico America/Antigua
+L America/Puerto_Rico America/Aruba
+L America/Panama America/Atikokan
+L America/Puerto_Rico America/Blanc-Sablon
+L America/Panama America/Cayman
+L America/Phoenix America/Creston
+L America/Puerto_Rico America/Curacao
+L America/Puerto_Rico America/Dominica
+L America/Puerto_Rico America/Grenada
+L America/Puerto_Rico America/Guadeloupe
+L America/Puerto_Rico America/Kralendijk
+L America/Puerto_Rico America/Lower_Princes
+L America/Puerto_Rico America/Marigot
+L America/Puerto_Rico America/Montserrat
+L America/Toronto America/Nassau
+L America/Puerto_Rico America/Port_of_Spain
+L America/Puerto_Rico America/St_Barthelemy
+L America/Puerto_Rico America/St_Kitts
+L America/Puerto_Rico America/St_Lucia
+L America/Puerto_Rico America/St_Thomas
+L America/Puerto_Rico America/St_Vincent
+L America/Puerto_Rico America/Tortola
+L Pacific/Port_Moresby Antarctica/DumontDUrville
+L Pacific/Auckland Antarctica/McMurdo
+L Asia/Riyadh Antarctica/Syowa
+L Europe/Berlin Arctic/Longyearbyen
+L Asia/Riyadh Asia/Aden
+L Asia/Qatar Asia/Bahrain
+L Asia/Kuching Asia/Brunei
+L Asia/Singapore Asia/Kuala_Lumpur
+L Asia/Riyadh Asia/Kuwait
+L Asia/Dubai Asia/Muscat
+L Asia/Bangkok Asia/Phnom_Penh
+L Asia/Bangkok Asia/Vientiane
+L Africa/Abidjan Atlantic/Reykjavik
+L Africa/Abidjan Atlantic/St_Helena
+L Europe/Brussels Europe/Amsterdam
+L Europe/Prague Europe/Bratislava
+L Europe/Zurich Europe/Busingen
+L Europe/Berlin Europe/Copenhagen
+L Europe/London Europe/Guernsey
+L Europe/London Europe/Isle_of_Man
+L Europe/London Europe/Jersey
+L Europe/Belgrade Europe/Ljubljana
+L Europe/Brussels Europe/Luxembourg
+L Europe/Helsinki Europe/Mariehamn
+L Europe/Paris Europe/Monaco
+L Europe/Berlin Europe/Oslo
+L Europe/Belgrade Europe/Podgorica
+L Europe/Rome Europe/San_Marino
+L Europe/Belgrade Europe/Sarajevo
+L Europe/Belgrade Europe/Skopje
+L Europe/Berlin Europe/Stockholm
+L Europe/Zurich Europe/Vaduz
+L Europe/Rome Europe/Vatican
+L Europe/Belgrade Europe/Zagreb
+L Africa/Nairobi Indian/Antananarivo
+L Asia/Bangkok Indian/Christmas
+L Asia/Yangon Indian/Cocos
+L Africa/Nairobi Indian/Comoro
+L Indian/Maldives Indian/Kerguelen
+L Asia/Dubai Indian/Mahe
+L Africa/Nairobi Indian/Mayotte
+L Asia/Dubai Indian/Reunion
+L Pacific/Port_Moresby Pacific/Chuuk
+L Pacific/Tarawa Pacific/Funafuti
+L Pacific/Tarawa Pacific/Majuro
+L Pacific/Pago_Pago Pacific/Midway
+L Pacific/Guadalcanal Pacific/Pohnpei
+L Pacific/Guam Pacific/Saipan
+L Pacific/Tarawa Pacific/Wake
+L Pacific/Tarawa Pacific/Wallis
+L Africa/Abidjan Africa/Timbuktu
+L America/Argentina/Catamarca America/Argentina/ComodRivadavia
+L America/Adak America/Atka
+L America/Panama America/Coral_Harbour
+L America/Tijuana America/Ensenada
+L America/Indiana/Indianapolis America/Fort_Wayne
+L America/Toronto America/Montreal
+L America/Toronto America/Nipigon
+L America/Iqaluit America/Pangnirtung
+L America/Rio_Branco America/Porto_Acre
+L America/Winnipeg America/Rainy_River
+L America/Argentina/Cordoba America/Rosario
+L America/Tijuana America/Santa_Isabel
+L America/Denver America/Shiprock
+L America/Toronto America/Thunder_Bay
+L America/Edmonton America/Yellowknife
+L Pacific/Auckland Antarctica/South_Pole
+L Asia/Ulaanbaatar Asia/Choibalsan
+L Asia/Shanghai Asia/Chongqing
+L Asia/Shanghai Asia/Harbin
+L Asia/Urumqi Asia/Kashgar
+L Asia/Jerusalem Asia/Tel_Aviv
+L Europe/Berlin Atlantic/Jan_Mayen
+L Australia/Sydney Australia/Canberra
+L Australia/Hobart Australia/Currie
+L Europe/London Europe/Belfast
+L Europe/Chisinau Europe/Tiraspol
+L Europe/Kyiv Europe/Uzhgorod
+L Europe/Kyiv Europe/Zaporozhye
+L Pacific/Kanton Pacific/Enderbury
+L Pacific/Honolulu Pacific/Johnston
+L Pacific/Port_Moresby Pacific/Yap
+L Europe/Lisbon WET
+L Africa/Nairobi Africa/Asmera
+L America/Nuuk America/Godthab
+L Asia/Ashgabat Asia/Ashkhabad
+L Asia/Kolkata Asia/Calcutta
+L Asia/Shanghai Asia/Chungking
+L Asia/Dhaka Asia/Dacca
+L Europe/Istanbul Asia/Istanbul
+L Asia/Kathmandu Asia/Katmandu
+L Asia/Macau Asia/Macao
+L Asia/Yangon Asia/Rangoon
+L Asia/Ho_Chi_Minh Asia/Saigon
+L Asia/Thimphu Asia/Thimbu
+L Asia/Makassar Asia/Ujung_Pandang
+L Asia/Ulaanbaatar Asia/Ulan_Bator
+L Atlantic/Faroe Atlantic/Faeroe
+L Europe/Kyiv Europe/Kiev
+L Asia/Nicosia Europe/Nicosia
+L Pacific/Honolulu HST
+L America/Los_Angeles PST8PDT
+L Pacific/Guadalcanal Pacific/Ponape
+L Pacific/Port_Moresby Pacific/Truk
diff --git a/marketing/share/zoneinfo/zone.tab b/marketing/share/zoneinfo/zone.tab
new file mode 100644
index 0000000000000000000000000000000000000000..d2be66359f3bed4cdd0e3d5a99342379f3d00b7c
--- /dev/null
+++ b/marketing/share/zoneinfo/zone.tab
@@ -0,0 +1,447 @@
+# tzdb timezone descriptions (deprecated version)
+#
+# This file is in the public domain, so clarified as of
+# 2009-05-17 by Arthur David Olson.
+#
+# From Paul Eggert (2021-09-20):
+# This file is intended as a backward-compatibility aid for older programs.
+# New programs should use zone1970.tab.  This file is like zone1970.tab (see
+# zone1970.tab's comments), but with the following additional restrictions:
+#
+# 1.  This file contains only ASCII characters.
+# 2.  The first data column contains exactly one country code.
+#
+# Because of (2), each row stands for an area that is the intersection
+# of a region identified by a country code and of a timezone where civil
+# clocks have agreed since 1970; this is a narrower definition than
+# that of zone1970.tab.
+#
+# Unlike zone1970.tab, a row's third column can be a Link from
+# 'backward' instead of a Zone.
+#
+# This table is intended as an aid for users, to help them select timezones
+# appropriate for their practical needs.  It is not intended to take or
+# endorse any position on legal or territorial claims.
+#
+#country-
+#code	coordinates	TZ			comments
+AD	+4230+00131	Europe/Andorra
+AE	+2518+05518	Asia/Dubai
+AF	+3431+06912	Asia/Kabul
+AG	+1703-06148	America/Antigua
+AI	+1812-06304	America/Anguilla
+AL	+4120+01950	Europe/Tirane
+AM	+4011+04430	Asia/Yerevan
+AO	-0848+01314	Africa/Luanda
+AQ	-7750+16636	Antarctica/McMurdo	New Zealand time - McMurdo, South Pole
+AQ	-6617+11031	Antarctica/Casey	Casey
+AQ	-6835+07758	Antarctica/Davis	Davis
+AQ	-6640+14001	Antarctica/DumontDUrville	Dumont-d'Urville
+AQ	-6736+06253	Antarctica/Mawson	Mawson
+AQ	-6448-06406	Antarctica/Palmer	Palmer
+AQ	-6734-06808	Antarctica/Rothera	Rothera
+AQ	-690022+0393524	Antarctica/Syowa	Syowa
+AQ	-720041+0023206	Antarctica/Troll	Troll
+AQ	-7824+10654	Antarctica/Vostok	Vostok
+AR	-3436-05827	America/Argentina/Buenos_Aires	Buenos Aires (BA, CF)
+AR	-3124-06411	America/Argentina/Cordoba	Argentina (most areas: CB, CC, CN, ER, FM, MN, SE, SF)
+AR	-2447-06525	America/Argentina/Salta	Salta (SA, LP, NQ, RN)
+AR	-2411-06518	America/Argentina/Jujuy	Jujuy (JY)
+AR	-2649-06513	America/Argentina/Tucuman	Tucuman (TM)
+AR	-2828-06547	America/Argentina/Catamarca	Catamarca (CT), Chubut (CH)
+AR	-2926-06651	America/Argentina/La_Rioja	La Rioja (LR)
+AR	-3132-06831	America/Argentina/San_Juan	San Juan (SJ)
+AR	-3253-06849	America/Argentina/Mendoza	Mendoza (MZ)
+AR	-3319-06621	America/Argentina/San_Luis	San Luis (SL)
+AR	-5138-06913	America/Argentina/Rio_Gallegos	Santa Cruz (SC)
+AR	-5448-06818	America/Argentina/Ushuaia	Tierra del Fuego (TF)
+AS	-1416-17042	Pacific/Pago_Pago
+AT	+4813+01620	Europe/Vienna
+AU	-3133+15905	Australia/Lord_Howe	Lord Howe Island
+AU	-5430+15857	Antarctica/Macquarie	Macquarie Island
+AU	-4253+14719	Australia/Hobart	Tasmania
+AU	-3749+14458	Australia/Melbourne	Victoria
+AU	-3352+15113	Australia/Sydney	New South Wales (most areas)
+AU	-3157+14127	Australia/Broken_Hill	New South Wales (Yancowinna)
+AU	-2728+15302	Australia/Brisbane	Queensland (most areas)
+AU	-2016+14900	Australia/Lindeman	Queensland (Whitsunday Islands)
+AU	-3455+13835	Australia/Adelaide	South Australia
+AU	-1228+13050	Australia/Darwin	Northern Territory
+AU	-3157+11551	Australia/Perth	Western Australia (most areas)
+AU	-3143+12852	Australia/Eucla	Western Australia (Eucla)
+AW	+1230-06958	America/Aruba
+AX	+6006+01957	Europe/Mariehamn
+AZ	+4023+04951	Asia/Baku
+BA	+4352+01825	Europe/Sarajevo
+BB	+1306-05937	America/Barbados
+BD	+2343+09025	Asia/Dhaka
+BE	+5050+00420	Europe/Brussels
+BF	+1222-00131	Africa/Ouagadougou
+BG	+4241+02319	Europe/Sofia
+BH	+2623+05035	Asia/Bahrain
+BI	-0323+02922	Africa/Bujumbura
+BJ	+0629+00237	Africa/Porto-Novo
+BL	+1753-06251	America/St_Barthelemy
+BM	+3217-06446	Atlantic/Bermuda
+BN	+0456+11455	Asia/Brunei
+BO	-1630-06809	America/La_Paz
+BQ	+120903-0681636	America/Kralendijk
+BR	-0351-03225	America/Noronha	Atlantic islands
+BR	-0127-04829	America/Belem	Para (east), Amapa
+BR	-0343-03830	America/Fortaleza	Brazil (northeast: MA, PI, CE, RN, PB)
+BR	-0803-03454	America/Recife	Pernambuco
+BR	-0712-04812	America/Araguaina	Tocantins
+BR	-0940-03543	America/Maceio	Alagoas, Sergipe
+BR	-1259-03831	America/Bahia	Bahia
+BR	-2332-04637	America/Sao_Paulo	Brazil (southeast: GO, DF, MG, ES, RJ, SP, PR, SC, RS)
+BR	-2027-05437	America/Campo_Grande	Mato Grosso do Sul
+BR	-1535-05605	America/Cuiaba	Mato Grosso
+BR	-0226-05452	America/Santarem	Para (west)
+BR	-0846-06354	America/Porto_Velho	Rondonia
+BR	+0249-06040	America/Boa_Vista	Roraima
+BR	-0308-06001	America/Manaus	Amazonas (east)
+BR	-0640-06952	America/Eirunepe	Amazonas (west)
+BR	-0958-06748	America/Rio_Branco	Acre
+BS	+2505-07721	America/Nassau
+BT	+2728+08939	Asia/Thimphu
+BW	-2439+02555	Africa/Gaborone
+BY	+5354+02734	Europe/Minsk
+BZ	+1730-08812	America/Belize
+CA	+4734-05243	America/St_Johns	Newfoundland, Labrador (SE)
+CA	+4439-06336	America/Halifax	Atlantic - NS (most areas), PE
+CA	+4612-05957	America/Glace_Bay	Atlantic - NS (Cape Breton)
+CA	+4606-06447	America/Moncton	Atlantic - New Brunswick
+CA	+5320-06025	America/Goose_Bay	Atlantic - Labrador (most areas)
+CA	+5125-05707	America/Blanc-Sablon	AST - QC (Lower North Shore)
+CA	+4339-07923	America/Toronto	Eastern - ON & QC (most areas)
+CA	+6344-06828	America/Iqaluit	Eastern - NU (most areas)
+CA	+484531-0913718	America/Atikokan	EST - ON (Atikokan), NU (Coral H)
+CA	+4953-09709	America/Winnipeg	Central - ON (west), Manitoba
+CA	+744144-0944945	America/Resolute	Central - NU (Resolute)
+CA	+624900-0920459	America/Rankin_Inlet	Central - NU (central)
+CA	+5024-10439	America/Regina	CST - SK (most areas)
+CA	+5017-10750	America/Swift_Current	CST - SK (midwest)
+CA	+5333-11328	America/Edmonton	Mountain - AB, BC(E), NT(E), SK(W)
+CA	+690650-1050310	America/Cambridge_Bay	Mountain - NU (west)
+CA	+682059-1334300	America/Inuvik	Mountain - NT (west)
+CA	+4906-11631	America/Creston	MST - BC (Creston)
+CA	+5546-12014	America/Dawson_Creek	MST - BC (Dawson Cr, Ft St John)
+CA	+5848-12242	America/Fort_Nelson	MST - BC (Ft Nelson)
+CA	+6043-13503	America/Whitehorse	MST - Yukon (east)
+CA	+6404-13925	America/Dawson	MST - Yukon (west)
+CA	+4916-12307	America/Vancouver	Pacific - BC (most areas)
+CC	-1210+09655	Indian/Cocos
+CD	-0418+01518	Africa/Kinshasa	Dem. Rep. of Congo (west)
+CD	-1140+02728	Africa/Lubumbashi	Dem. Rep. of Congo (east)
+CF	+0422+01835	Africa/Bangui
+CG	-0416+01517	Africa/Brazzaville
+CH	+4723+00832	Europe/Zurich
+CI	+0519-00402	Africa/Abidjan
+CK	-2114-15946	Pacific/Rarotonga
+CL	-3327-07040	America/Santiago	most of Chile
+CL	-5309-07055	America/Punta_Arenas	Region of Magallanes
+CL	-2709-10926	Pacific/Easter	Easter Island
+CM	+0403+00942	Africa/Douala
+CN	+3114+12128	Asia/Shanghai	Beijing Time
+CN	+4348+08735	Asia/Urumqi	Xinjiang Time
+CO	+0436-07405	America/Bogota
+CR	+0956-08405	America/Costa_Rica
+CU	+2308-08222	America/Havana
+CV	+1455-02331	Atlantic/Cape_Verde
+CW	+1211-06900	America/Curacao
+CX	-1025+10543	Indian/Christmas
+CY	+3510+03322	Asia/Nicosia	most of Cyprus
+CY	+3507+03357	Asia/Famagusta	Northern Cyprus
+CZ	+5005+01426	Europe/Prague
+DE	+5230+01322	Europe/Berlin	most of Germany
+DE	+4742+00841	Europe/Busingen	Busingen
+DJ	+1136+04309	Africa/Djibouti
+DK	+5540+01235	Europe/Copenhagen
+DM	+1518-06124	America/Dominica
+DO	+1828-06954	America/Santo_Domingo
+DZ	+3647+00303	Africa/Algiers
+EC	-0210-07950	America/Guayaquil	Ecuador (mainland)
+EC	-0054-08936	Pacific/Galapagos	Galapagos Islands
+EE	+5925+02445	Europe/Tallinn
+EG	+3003+03115	Africa/Cairo
+EH	+2709-01312	Africa/El_Aaiun
+ER	+1520+03853	Africa/Asmara
+ES	+4024-00341	Europe/Madrid	Spain (mainland)
+ES	+3553-00519	Africa/Ceuta	Ceuta, Melilla
+ES	+2806-01524	Atlantic/Canary	Canary Islands
+ET	+0902+03842	Africa/Addis_Ababa
+FI	+6010+02458	Europe/Helsinki
+FJ	-1808+17825	Pacific/Fiji
+FK	-5142-05751	Atlantic/Stanley
+FM	+0725+15147	Pacific/Chuuk	Chuuk/Truk, Yap
+FM	+0658+15813	Pacific/Pohnpei	Pohnpei/Ponape
+FM	+0519+16259	Pacific/Kosrae	Kosrae
+FO	+6201-00646	Atlantic/Faroe
+FR	+4852+00220	Europe/Paris
+GA	+0023+00927	Africa/Libreville
+GB	+513030-0000731	Europe/London
+GD	+1203-06145	America/Grenada
+GE	+4143+04449	Asia/Tbilisi
+GF	+0456-05220	America/Cayenne
+GG	+492717-0023210	Europe/Guernsey
+GH	+0533-00013	Africa/Accra
+GI	+3608-00521	Europe/Gibraltar
+GL	+6411-05144	America/Nuuk	most of Greenland
+GL	+7646-01840	America/Danmarkshavn	National Park (east coast)
+GL	+7029-02158	America/Scoresbysund	Scoresbysund/Ittoqqortoormiit
+GL	+7634-06847	America/Thule	Thule/Pituffik
+GM	+1328-01639	Africa/Banjul
+GN	+0931-01343	Africa/Conakry
+GP	+1614-06132	America/Guadeloupe
+GQ	+0345+00847	Africa/Malabo
+GR	+3758+02343	Europe/Athens
+GS	-5416-03632	Atlantic/South_Georgia
+GT	+1438-09031	America/Guatemala
+GU	+1328+14445	Pacific/Guam
+GW	+1151-01535	Africa/Bissau
+GY	+0648-05810	America/Guyana
+HK	+2217+11409	Asia/Hong_Kong
+HN	+1406-08713	America/Tegucigalpa
+HR	+4548+01558	Europe/Zagreb
+HT	+1832-07220	America/Port-au-Prince
+HU	+4730+01905	Europe/Budapest
+ID	-0610+10648	Asia/Jakarta	Java, Sumatra
+ID	-0002+10920	Asia/Pontianak	Borneo (west, central)
+ID	-0507+11924	Asia/Makassar	Borneo (east, south), Sulawesi/Celebes, Bali, Nusa Tengarra, Timor (west)
+ID	-0232+14042	Asia/Jayapura	New Guinea (West Papua / Irian Jaya), Malukus/Moluccas
+IE	+5320-00615	Europe/Dublin
+IL	+314650+0351326	Asia/Jerusalem
+IM	+5409-00428	Europe/Isle_of_Man
+IN	+2232+08822	Asia/Kolkata
+IO	-0720+07225	Indian/Chagos
+IQ	+3321+04425	Asia/Baghdad
+IR	+3540+05126	Asia/Tehran
+IS	+6409-02151	Atlantic/Reykjavik
+IT	+4154+01229	Europe/Rome
+JE	+491101-0020624	Europe/Jersey
+JM	+175805-0764736	America/Jamaica
+JO	+3157+03556	Asia/Amman
+JP	+353916+1394441	Asia/Tokyo
+KE	-0117+03649	Africa/Nairobi
+KG	+4254+07436	Asia/Bishkek
+KH	+1133+10455	Asia/Phnom_Penh
+KI	+0125+17300	Pacific/Tarawa	Gilbert Islands
+KI	-0247-17143	Pacific/Kanton	Phoenix Islands
+KI	+0152-15720	Pacific/Kiritimati	Line Islands
+KM	-1141+04316	Indian/Comoro
+KN	+1718-06243	America/St_Kitts
+KP	+3901+12545	Asia/Pyongyang
+KR	+3733+12658	Asia/Seoul
+KW	+2920+04759	Asia/Kuwait
+KY	+1918-08123	America/Cayman
+KZ	+4315+07657	Asia/Almaty	most of Kazakhstan
+KZ	+4448+06528	Asia/Qyzylorda	Qyzylorda/Kyzylorda/Kzyl-Orda
+KZ	+5312+06337	Asia/Qostanay	Qostanay/Kostanay/Kustanay
+KZ	+5017+05710	Asia/Aqtobe	Aqtobe/Aktobe
+KZ	+4431+05016	Asia/Aqtau	Mangghystau/Mankistau
+KZ	+4707+05156	Asia/Atyrau	Atyrau/Atirau/Gur'yev
+KZ	+5113+05121	Asia/Oral	West Kazakhstan
+LA	+1758+10236	Asia/Vientiane
+LB	+3353+03530	Asia/Beirut
+LC	+1401-06100	America/St_Lucia
+LI	+4709+00931	Europe/Vaduz
+LK	+0656+07951	Asia/Colombo
+LR	+0618-01047	Africa/Monrovia
+LS	-2928+02730	Africa/Maseru
+LT	+5441+02519	Europe/Vilnius
+LU	+4936+00609	Europe/Luxembourg
+LV	+5657+02406	Europe/Riga
+LY	+3254+01311	Africa/Tripoli
+MA	+3339-00735	Africa/Casablanca
+MC	+4342+00723	Europe/Monaco
+MD	+4700+02850	Europe/Chisinau
+ME	+4226+01916	Europe/Podgorica
+MF	+1804-06305	America/Marigot
+MG	-1855+04731	Indian/Antananarivo
+MH	+0709+17112	Pacific/Majuro	most of Marshall Islands
+MH	+0905+16720	Pacific/Kwajalein	Kwajalein
+MK	+4159+02126	Europe/Skopje
+ML	+1239-00800	Africa/Bamako
+MM	+1647+09610	Asia/Yangon
+MN	+4755+10653	Asia/Ulaanbaatar	most of Mongolia
+MN	+4801+09139	Asia/Hovd	Bayan-Olgii, Hovd, Uvs
+MO	+221150+1133230	Asia/Macau
+MP	+1512+14545	Pacific/Saipan
+MQ	+1436-06105	America/Martinique
+MR	+1806-01557	Africa/Nouakchott
+MS	+1643-06213	America/Montserrat
+MT	+3554+01431	Europe/Malta
+MU	-2010+05730	Indian/Mauritius
+MV	+0410+07330	Indian/Maldives
+MW	-1547+03500	Africa/Blantyre
+MX	+1924-09909	America/Mexico_City	Central Mexico
+MX	+2105-08646	America/Cancun	Quintana Roo
+MX	+2058-08937	America/Merida	Campeche, Yucatan
+MX	+2540-10019	America/Monterrey	Durango; Coahuila, Nuevo Leon, Tamaulipas (most areas)
+MX	+2550-09730	America/Matamoros	Coahuila, Nuevo Leon, Tamaulipas (US border)
+MX	+2838-10605	America/Chihuahua	Chihuahua (most areas)
+MX	+3144-10629	America/Ciudad_Juarez	Chihuahua (US border - west)
+MX	+2934-10425	America/Ojinaga	Chihuahua (US border - east)
+MX	+2313-10625	America/Mazatlan	Baja California Sur, Nayarit (most areas), Sinaloa
+MX	+2048-10515	America/Bahia_Banderas	Bahia de Banderas
+MX	+2904-11058	America/Hermosillo	Sonora
+MX	+3232-11701	America/Tijuana	Baja California
+MY	+0310+10142	Asia/Kuala_Lumpur	Malaysia (peninsula)
+MY	+0133+11020	Asia/Kuching	Sabah, Sarawak
+MZ	-2558+03235	Africa/Maputo
+NA	-2234+01706	Africa/Windhoek
+NC	-2216+16627	Pacific/Noumea
+NE	+1331+00207	Africa/Niamey
+NF	-2903+16758	Pacific/Norfolk
+NG	+0627+00324	Africa/Lagos
+NI	+1209-08617	America/Managua
+NL	+5222+00454	Europe/Amsterdam
+NO	+5955+01045	Europe/Oslo
+NP	+2743+08519	Asia/Kathmandu
+NR	-0031+16655	Pacific/Nauru
+NU	-1901-16955	Pacific/Niue
+NZ	-3652+17446	Pacific/Auckland	most of New Zealand
+NZ	-4357-17633	Pacific/Chatham	Chatham Islands
+OM	+2336+05835	Asia/Muscat
+PA	+0858-07932	America/Panama
+PE	-1203-07703	America/Lima
+PF	-1732-14934	Pacific/Tahiti	Society Islands
+PF	-0900-13930	Pacific/Marquesas	Marquesas Islands
+PF	-2308-13457	Pacific/Gambier	Gambier Islands
+PG	-0930+14710	Pacific/Port_Moresby	most of Papua New Guinea
+PG	-0613+15534	Pacific/Bougainville	Bougainville
+PH	+143512+1205804	Asia/Manila
+PK	+2452+06703	Asia/Karachi
+PL	+5215+02100	Europe/Warsaw
+PM	+4703-05620	America/Miquelon
+PN	-2504-13005	Pacific/Pitcairn
+PR	+182806-0660622	America/Puerto_Rico
+PS	+3130+03428	Asia/Gaza	Gaza Strip
+PS	+313200+0350542	Asia/Hebron	West Bank
+PT	+3843-00908	Europe/Lisbon	Portugal (mainland)
+PT	+3238-01654	Atlantic/Madeira	Madeira Islands
+PT	+3744-02540	Atlantic/Azores	Azores
+PW	+0720+13429	Pacific/Palau
+PY	-2516-05740	America/Asuncion
+QA	+2517+05132	Asia/Qatar
+RE	-2052+05528	Indian/Reunion
+RO	+4426+02606	Europe/Bucharest
+RS	+4450+02030	Europe/Belgrade
+RU	+5443+02030	Europe/Kaliningrad	MSK-01 - Kaliningrad
+RU	+554521+0373704	Europe/Moscow	MSK+00 - Moscow area
+# The obsolescent zone.tab format cannot represent Europe/Simferopol well.
+# Put it in RU section and list as UA.  See "territorial claims" above.
+# Programs should use zone1970.tab instead; see above.
+UA	+4457+03406	Europe/Simferopol	Crimea
+RU	+5836+04939	Europe/Kirov	MSK+00 - Kirov
+RU	+4844+04425	Europe/Volgograd	MSK+00 - Volgograd
+RU	+4621+04803	Europe/Astrakhan	MSK+01 - Astrakhan
+RU	+5134+04602	Europe/Saratov	MSK+01 - Saratov
+RU	+5420+04824	Europe/Ulyanovsk	MSK+01 - Ulyanovsk
+RU	+5312+05009	Europe/Samara	MSK+01 - Samara, Udmurtia
+RU	+5651+06036	Asia/Yekaterinburg	MSK+02 - Urals
+RU	+5500+07324	Asia/Omsk	MSK+03 - Omsk
+RU	+5502+08255	Asia/Novosibirsk	MSK+04 - Novosibirsk
+RU	+5322+08345	Asia/Barnaul	MSK+04 - Altai
+RU	+5630+08458	Asia/Tomsk	MSK+04 - Tomsk
+RU	+5345+08707	Asia/Novokuznetsk	MSK+04 - Kemerovo
+RU	+5601+09250	Asia/Krasnoyarsk	MSK+04 - Krasnoyarsk area
+RU	+5216+10420	Asia/Irkutsk	MSK+05 - Irkutsk, Buryatia
+RU	+5203+11328	Asia/Chita	MSK+06 - Zabaykalsky
+RU	+6200+12940	Asia/Yakutsk	MSK+06 - Lena River
+RU	+623923+1353314	Asia/Khandyga	MSK+06 - Tomponsky, Ust-Maysky
+RU	+4310+13156	Asia/Vladivostok	MSK+07 - Amur River
+RU	+643337+1431336	Asia/Ust-Nera	MSK+07 - Oymyakonsky
+RU	+5934+15048	Asia/Magadan	MSK+08 - Magadan
+RU	+4658+14242	Asia/Sakhalin	MSK+08 - Sakhalin Island
+RU	+6728+15343	Asia/Srednekolymsk	MSK+08 - Sakha (E), N Kuril Is
+RU	+5301+15839	Asia/Kamchatka	MSK+09 - Kamchatka
+RU	+6445+17729	Asia/Anadyr	MSK+09 - Bering Sea
+RW	-0157+03004	Africa/Kigali
+SA	+2438+04643	Asia/Riyadh
+SB	-0932+16012	Pacific/Guadalcanal
+SC	-0440+05528	Indian/Mahe
+SD	+1536+03232	Africa/Khartoum
+SE	+5920+01803	Europe/Stockholm
+SG	+0117+10351	Asia/Singapore
+SH	-1555-00542	Atlantic/St_Helena
+SI	+4603+01431	Europe/Ljubljana
+SJ	+7800+01600	Arctic/Longyearbyen
+SK	+4809+01707	Europe/Bratislava
+SL	+0830-01315	Africa/Freetown
+SM	+4355+01228	Europe/San_Marino
+SN	+1440-01726	Africa/Dakar
+SO	+0204+04522	Africa/Mogadishu
+SR	+0550-05510	America/Paramaribo
+SS	+0451+03137	Africa/Juba
+ST	+0020+00644	Africa/Sao_Tome
+SV	+1342-08912	America/El_Salvador
+SX	+180305-0630250	America/Lower_Princes
+SY	+3330+03618	Asia/Damascus
+SZ	-2618+03106	Africa/Mbabane
+TC	+2128-07108	America/Grand_Turk
+TD	+1207+01503	Africa/Ndjamena
+TF	-492110+0701303	Indian/Kerguelen
+TG	+0608+00113	Africa/Lome
+TH	+1345+10031	Asia/Bangkok
+TJ	+3835+06848	Asia/Dushanbe
+TK	-0922-17114	Pacific/Fakaofo
+TL	-0833+12535	Asia/Dili
+TM	+3757+05823	Asia/Ashgabat
+TN	+3648+01011	Africa/Tunis
+TO	-210800-1751200	Pacific/Tongatapu
+TR	+4101+02858	Europe/Istanbul
+TT	+1039-06131	America/Port_of_Spain
+TV	-0831+17913	Pacific/Funafuti
+TW	+2503+12130	Asia/Taipei
+TZ	-0648+03917	Africa/Dar_es_Salaam
+UA	+5026+03031	Europe/Kyiv	most of Ukraine
+UG	+0019+03225	Africa/Kampala
+UM	+2813-17722	Pacific/Midway	Midway Islands
+UM	+1917+16637	Pacific/Wake	Wake Island
+US	+404251-0740023	America/New_York	Eastern (most areas)
+US	+421953-0830245	America/Detroit	Eastern - MI (most areas)
+US	+381515-0854534	America/Kentucky/Louisville	Eastern - KY (Louisville area)
+US	+364947-0845057	America/Kentucky/Monticello	Eastern - KY (Wayne)
+US	+394606-0860929	America/Indiana/Indianapolis	Eastern - IN (most areas)
+US	+384038-0873143	America/Indiana/Vincennes	Eastern - IN (Da, Du, K, Mn)
+US	+410305-0863611	America/Indiana/Winamac	Eastern - IN (Pulaski)
+US	+382232-0862041	America/Indiana/Marengo	Eastern - IN (Crawford)
+US	+382931-0871643	America/Indiana/Petersburg	Eastern - IN (Pike)
+US	+384452-0850402	America/Indiana/Vevay	Eastern - IN (Switzerland)
+US	+415100-0873900	America/Chicago	Central (most areas)
+US	+375711-0864541	America/Indiana/Tell_City	Central - IN (Perry)
+US	+411745-0863730	America/Indiana/Knox	Central - IN (Starke)
+US	+450628-0873651	America/Menominee	Central - MI (Wisconsin border)
+US	+470659-1011757	America/North_Dakota/Center	Central - ND (Oliver)
+US	+465042-1012439	America/North_Dakota/New_Salem	Central - ND (Morton rural)
+US	+471551-1014640	America/North_Dakota/Beulah	Central - ND (Mercer)
+US	+394421-1045903	America/Denver	Mountain (most areas)
+US	+433649-1161209	America/Boise	Mountain - ID (south), OR (east)
+US	+332654-1120424	America/Phoenix	MST - AZ (except Navajo)
+US	+340308-1181434	America/Los_Angeles	Pacific
+US	+611305-1495401	America/Anchorage	Alaska (most areas)
+US	+581807-1342511	America/Juneau	Alaska - Juneau area
+US	+571035-1351807	America/Sitka	Alaska - Sitka area
+US	+550737-1313435	America/Metlakatla	Alaska - Annette Island
+US	+593249-1394338	America/Yakutat	Alaska - Yakutat
+US	+643004-1652423	America/Nome	Alaska (west)
+US	+515248-1763929	America/Adak	Alaska - western Aleutians
+US	+211825-1575130	Pacific/Honolulu	Hawaii
+UY	-345433-0561245	America/Montevideo
+UZ	+3940+06648	Asia/Samarkand	Uzbekistan (west)
+UZ	+4120+06918	Asia/Tashkent	Uzbekistan (east)
+VA	+415408+0122711	Europe/Vatican
+VC	+1309-06114	America/St_Vincent
+VE	+1030-06656	America/Caracas
+VG	+1827-06437	America/Tortola
+VI	+1821-06456	America/St_Thomas
+VN	+1045+10640	Asia/Ho_Chi_Minh
+VU	-1740+16825	Pacific/Efate
+WF	-1318-17610	Pacific/Wallis
+WS	-1350-17144	Pacific/Apia
+YE	+1245+04512	Asia/Aden
+YT	-1247+04514	Indian/Mayotte
+ZA	-2615+02800	Africa/Johannesburg
+ZM	-1525+02817	Africa/Lusaka
+ZW	-1750+03103	Africa/Harare
diff --git a/marketing/share/zoneinfo/zone1970.tab b/marketing/share/zoneinfo/zone1970.tab
new file mode 100644
index 0000000000000000000000000000000000000000..5ded0565ebf31764012b71420e4da1192ac5378c
--- /dev/null
+++ b/marketing/share/zoneinfo/zone1970.tab
@@ -0,0 +1,374 @@
+# tzdb timezone descriptions
+#
+# This file is in the public domain.
+#
+# From Paul Eggert (2018-06-27):
+# This file contains a table where each row stands for a timezone where
+# civil timestamps have agreed since 1970.  Columns are separated by
+# a single tab.  Lines beginning with '#' are comments.  All text uses
+# UTF-8 encoding.  The columns of the table are as follows:
+#
+# 1.  The countries that overlap the timezone, as a comma-separated list
+#     of ISO 3166 2-character country codes.  See the file 'iso3166.tab'.
+# 2.  Latitude and longitude of the timezone's principal location
+#     in ISO 6709 sign-degrees-minutes-seconds format,
+#     either ±DDMM±DDDMM or ±DDMMSS±DDDMMSS,
+#     first latitude (+ is north), then longitude (+ is east).
+# 3.  Timezone name used in value of TZ environment variable.
+#     Please see the theory.html file for how these names are chosen.
+#     If multiple timezones overlap a country, each has a row in the
+#     table, with each column 1 containing the country code.
+# 4.  Comments; present if and only if countries have multiple timezones,
+#     and useful only for those countries.  For example, the comments
+#     for the row with countries CH,DE,LI and name Europe/Zurich
+#     are useful only for DE, since CH and LI have no other timezones.
+#
+# If a timezone covers multiple countries, the most-populous city is used,
+# and that country is listed first in column 1; any other countries
+# are listed alphabetically by country code.  The table is sorted
+# first by country code, then (if possible) by an order within the
+# country that (1) makes some geographical sense, and (2) puts the
+# most populous timezones first, where that does not contradict (1).
+#
+# This table is intended as an aid for users, to help them select timezones
+# appropriate for their practical needs.  It is not intended to take or
+# endorse any position on legal or territorial claims.
+#
+#country-
+#codes	coordinates	TZ	comments
+AD	+4230+00131	Europe/Andorra
+AE,OM,RE,SC,TF	+2518+05518	Asia/Dubai	Crozet
+AF	+3431+06912	Asia/Kabul
+AL	+4120+01950	Europe/Tirane
+AM	+4011+04430	Asia/Yerevan
+AQ	-6617+11031	Antarctica/Casey	Casey
+AQ	-6835+07758	Antarctica/Davis	Davis
+AQ	-6736+06253	Antarctica/Mawson	Mawson
+AQ	-6448-06406	Antarctica/Palmer	Palmer
+AQ	-6734-06808	Antarctica/Rothera	Rothera
+AQ	-720041+0023206	Antarctica/Troll	Troll
+AQ	-7824+10654	Antarctica/Vostok	Vostok
+AR	-3436-05827	America/Argentina/Buenos_Aires	Buenos Aires (BA, CF)
+AR	-3124-06411	America/Argentina/Cordoba	most areas: CB, CC, CN, ER, FM, MN, SE, SF
+AR	-2447-06525	America/Argentina/Salta	Salta (SA, LP, NQ, RN)
+AR	-2411-06518	America/Argentina/Jujuy	Jujuy (JY)
+AR	-2649-06513	America/Argentina/Tucuman	Tucumán (TM)
+AR	-2828-06547	America/Argentina/Catamarca	Catamarca (CT), Chubut (CH)
+AR	-2926-06651	America/Argentina/La_Rioja	La Rioja (LR)
+AR	-3132-06831	America/Argentina/San_Juan	San Juan (SJ)
+AR	-3253-06849	America/Argentina/Mendoza	Mendoza (MZ)
+AR	-3319-06621	America/Argentina/San_Luis	San Luis (SL)
+AR	-5138-06913	America/Argentina/Rio_Gallegos	Santa Cruz (SC)
+AR	-5448-06818	America/Argentina/Ushuaia	Tierra del Fuego (TF)
+AS,UM	-1416-17042	Pacific/Pago_Pago	Midway
+AT	+4813+01620	Europe/Vienna
+AU	-3133+15905	Australia/Lord_Howe	Lord Howe Island
+AU	-5430+15857	Antarctica/Macquarie	Macquarie Island
+AU	-4253+14719	Australia/Hobart	Tasmania
+AU	-3749+14458	Australia/Melbourne	Victoria
+AU	-3352+15113	Australia/Sydney	New South Wales (most areas)
+AU	-3157+14127	Australia/Broken_Hill	New South Wales (Yancowinna)
+AU	-2728+15302	Australia/Brisbane	Queensland (most areas)
+AU	-2016+14900	Australia/Lindeman	Queensland (Whitsunday Islands)
+AU	-3455+13835	Australia/Adelaide	South Australia
+AU	-1228+13050	Australia/Darwin	Northern Territory
+AU	-3157+11551	Australia/Perth	Western Australia (most areas)
+AU	-3143+12852	Australia/Eucla	Western Australia (Eucla)
+AZ	+4023+04951	Asia/Baku
+BB	+1306-05937	America/Barbados
+BD	+2343+09025	Asia/Dhaka
+BE,LU,NL	+5050+00420	Europe/Brussels
+BG	+4241+02319	Europe/Sofia
+BM	+3217-06446	Atlantic/Bermuda
+BO	-1630-06809	America/La_Paz
+BR	-0351-03225	America/Noronha	Atlantic islands
+BR	-0127-04829	America/Belem	Pará (east), Amapá
+BR	-0343-03830	America/Fortaleza	Brazil (northeast: MA, PI, CE, RN, PB)
+BR	-0803-03454	America/Recife	Pernambuco
+BR	-0712-04812	America/Araguaina	Tocantins
+BR	-0940-03543	America/Maceio	Alagoas, Sergipe
+BR	-1259-03831	America/Bahia	Bahia
+BR	-2332-04637	America/Sao_Paulo	Brazil (southeast: GO, DF, MG, ES, RJ, SP, PR, SC, RS)
+BR	-2027-05437	America/Campo_Grande	Mato Grosso do Sul
+BR	-1535-05605	America/Cuiaba	Mato Grosso
+BR	-0226-05452	America/Santarem	Pará (west)
+BR	-0846-06354	America/Porto_Velho	Rondônia
+BR	+0249-06040	America/Boa_Vista	Roraima
+BR	-0308-06001	America/Manaus	Amazonas (east)
+BR	-0640-06952	America/Eirunepe	Amazonas (west)
+BR	-0958-06748	America/Rio_Branco	Acre
+BT	+2728+08939	Asia/Thimphu
+BY	+5354+02734	Europe/Minsk
+BZ	+1730-08812	America/Belize
+CA	+4734-05243	America/St_Johns	Newfoundland, Labrador (SE)
+CA	+4439-06336	America/Halifax	Atlantic - NS (most areas), PE
+CA	+4612-05957	America/Glace_Bay	Atlantic - NS (Cape Breton)
+CA	+4606-06447	America/Moncton	Atlantic - New Brunswick
+CA	+5320-06025	America/Goose_Bay	Atlantic - Labrador (most areas)
+CA,BS	+4339-07923	America/Toronto	Eastern - ON & QC (most areas)
+CA	+6344-06828	America/Iqaluit	Eastern - NU (most areas)
+CA	+4953-09709	America/Winnipeg	Central - ON (west), Manitoba
+CA	+744144-0944945	America/Resolute	Central - NU (Resolute)
+CA	+624900-0920459	America/Rankin_Inlet	Central - NU (central)
+CA	+5024-10439	America/Regina	CST - SK (most areas)
+CA	+5017-10750	America/Swift_Current	CST - SK (midwest)
+CA	+5333-11328	America/Edmonton	Mountain - AB, BC(E), NT(E), SK(W)
+CA	+690650-1050310	America/Cambridge_Bay	Mountain - NU (west)
+CA	+682059-1334300	America/Inuvik	Mountain - NT (west)
+CA	+5546-12014	America/Dawson_Creek	MST - BC (Dawson Cr, Ft St John)
+CA	+5848-12242	America/Fort_Nelson	MST - BC (Ft Nelson)
+CA	+6043-13503	America/Whitehorse	MST - Yukon (east)
+CA	+6404-13925	America/Dawson	MST - Yukon (west)
+CA	+4916-12307	America/Vancouver	Pacific - BC (most areas)
+CH,DE,LI	+4723+00832	Europe/Zurich	Büsingen
+CI,BF,GH,GM,GN,IS,ML,MR,SH,SL,SN,TG	+0519-00402	Africa/Abidjan
+CK	-2114-15946	Pacific/Rarotonga
+CL	-3327-07040	America/Santiago	most of Chile
+CL	-5309-07055	America/Punta_Arenas	Region of Magallanes
+CL	-2709-10926	Pacific/Easter	Easter Island
+CN	+3114+12128	Asia/Shanghai	Beijing Time
+CN	+4348+08735	Asia/Urumqi	Xinjiang Time
+CO	+0436-07405	America/Bogota
+CR	+0956-08405	America/Costa_Rica
+CU	+2308-08222	America/Havana
+CV	+1455-02331	Atlantic/Cape_Verde
+CY	+3510+03322	Asia/Nicosia	most of Cyprus
+CY	+3507+03357	Asia/Famagusta	Northern Cyprus
+CZ,SK	+5005+01426	Europe/Prague
+DE,DK,NO,SE,SJ	+5230+01322	Europe/Berlin	most of Germany
+DO	+1828-06954	America/Santo_Domingo
+DZ	+3647+00303	Africa/Algiers
+EC	-0210-07950	America/Guayaquil	Ecuador (mainland)
+EC	-0054-08936	Pacific/Galapagos	Galápagos Islands
+EE	+5925+02445	Europe/Tallinn
+EG	+3003+03115	Africa/Cairo
+EH	+2709-01312	Africa/El_Aaiun
+ES	+4024-00341	Europe/Madrid	Spain (mainland)
+ES	+3553-00519	Africa/Ceuta	Ceuta, Melilla
+ES	+2806-01524	Atlantic/Canary	Canary Islands
+FI,AX	+6010+02458	Europe/Helsinki
+FJ	-1808+17825	Pacific/Fiji
+FK	-5142-05751	Atlantic/Stanley
+FM	+0519+16259	Pacific/Kosrae	Kosrae
+FO	+6201-00646	Atlantic/Faroe
+FR,MC	+4852+00220	Europe/Paris
+GB,GG,IM,JE	+513030-0000731	Europe/London
+GE	+4143+04449	Asia/Tbilisi
+GF	+0456-05220	America/Cayenne
+GI	+3608-00521	Europe/Gibraltar
+GL	+6411-05144	America/Nuuk	most of Greenland
+GL	+7646-01840	America/Danmarkshavn	National Park (east coast)
+GL	+7029-02158	America/Scoresbysund	Scoresbysund/Ittoqqortoormiit
+GL	+7634-06847	America/Thule	Thule/Pituffik
+GR	+3758+02343	Europe/Athens
+GS	-5416-03632	Atlantic/South_Georgia
+GT	+1438-09031	America/Guatemala
+GU,MP	+1328+14445	Pacific/Guam
+GW	+1151-01535	Africa/Bissau
+GY	+0648-05810	America/Guyana
+HK	+2217+11409	Asia/Hong_Kong
+HN	+1406-08713	America/Tegucigalpa
+HT	+1832-07220	America/Port-au-Prince
+HU	+4730+01905	Europe/Budapest
+ID	-0610+10648	Asia/Jakarta	Java, Sumatra
+ID	-0002+10920	Asia/Pontianak	Borneo (west, central)
+ID	-0507+11924	Asia/Makassar	Borneo (east, south), Sulawesi/Celebes, Bali, Nusa Tengarra, Timor (west)
+ID	-0232+14042	Asia/Jayapura	New Guinea (West Papua / Irian Jaya), Malukus/Moluccas
+IE	+5320-00615	Europe/Dublin
+IL	+314650+0351326	Asia/Jerusalem
+IN	+2232+08822	Asia/Kolkata
+IO	-0720+07225	Indian/Chagos
+IQ	+3321+04425	Asia/Baghdad
+IR	+3540+05126	Asia/Tehran
+IT,SM,VA	+4154+01229	Europe/Rome
+JM	+175805-0764736	America/Jamaica
+JO	+3157+03556	Asia/Amman
+JP,AU	+353916+1394441	Asia/Tokyo	Eyre Bird Observatory
+KE,DJ,ER,ET,KM,MG,SO,TZ,UG,YT	-0117+03649	Africa/Nairobi
+KG	+4254+07436	Asia/Bishkek
+KI,MH,TV,UM,WF	+0125+17300	Pacific/Tarawa	Gilberts, Marshalls, Wake
+KI	-0247-17143	Pacific/Kanton	Phoenix Islands
+KI	+0152-15720	Pacific/Kiritimati	Line Islands
+KP	+3901+12545	Asia/Pyongyang
+KR	+3733+12658	Asia/Seoul
+KZ	+4315+07657	Asia/Almaty	most of Kazakhstan
+KZ	+4448+06528	Asia/Qyzylorda	Qyzylorda/Kyzylorda/Kzyl-Orda
+KZ	+5312+06337	Asia/Qostanay	Qostanay/Kostanay/Kustanay
+KZ	+5017+05710	Asia/Aqtobe	Aqtöbe/Aktobe
+KZ	+4431+05016	Asia/Aqtau	Mangghystaū/Mankistau
+KZ	+4707+05156	Asia/Atyrau	Atyraū/Atirau/Gur'yev
+KZ	+5113+05121	Asia/Oral	West Kazakhstan
+LB	+3353+03530	Asia/Beirut
+LK	+0656+07951	Asia/Colombo
+LR	+0618-01047	Africa/Monrovia
+LT	+5441+02519	Europe/Vilnius
+LV	+5657+02406	Europe/Riga
+LY	+3254+01311	Africa/Tripoli
+MA	+3339-00735	Africa/Casablanca
+MD	+4700+02850	Europe/Chisinau
+MH	+0905+16720	Pacific/Kwajalein	Kwajalein
+MM,CC	+1647+09610	Asia/Yangon
+MN	+4755+10653	Asia/Ulaanbaatar	most of Mongolia
+MN	+4801+09139	Asia/Hovd	Bayan-Ölgii, Hovd, Uvs
+MO	+221150+1133230	Asia/Macau
+MQ	+1436-06105	America/Martinique
+MT	+3554+01431	Europe/Malta
+MU	-2010+05730	Indian/Mauritius
+MV,TF	+0410+07330	Indian/Maldives	Kerguelen, St Paul I, Amsterdam I
+MX	+1924-09909	America/Mexico_City	Central Mexico
+MX	+2105-08646	America/Cancun	Quintana Roo
+MX	+2058-08937	America/Merida	Campeche, Yucatán
+MX	+2540-10019	America/Monterrey	Durango; Coahuila, Nuevo León, Tamaulipas (most areas)
+MX	+2550-09730	America/Matamoros	Coahuila, Nuevo León, Tamaulipas (US border)
+MX	+2838-10605	America/Chihuahua	Chihuahua (most areas)
+MX	+3144-10629	America/Ciudad_Juarez	Chihuahua (US border - west)
+MX	+2934-10425	America/Ojinaga	Chihuahua (US border - east)
+MX	+2313-10625	America/Mazatlan	Baja California Sur, Nayarit (most areas), Sinaloa
+MX	+2048-10515	America/Bahia_Banderas	Bahía de Banderas
+MX	+2904-11058	America/Hermosillo	Sonora
+MX	+3232-11701	America/Tijuana	Baja California
+MY,BN	+0133+11020	Asia/Kuching	Sabah, Sarawak
+MZ,BI,BW,CD,MW,RW,ZM,ZW	-2558+03235	Africa/Maputo	Central Africa Time
+NA	-2234+01706	Africa/Windhoek
+NC	-2216+16627	Pacific/Noumea
+NF	-2903+16758	Pacific/Norfolk
+NG,AO,BJ,CD,CF,CG,CM,GA,GQ,NE	+0627+00324	Africa/Lagos	West Africa Time
+NI	+1209-08617	America/Managua
+NP	+2743+08519	Asia/Kathmandu
+NR	-0031+16655	Pacific/Nauru
+NU	-1901-16955	Pacific/Niue
+NZ,AQ	-3652+17446	Pacific/Auckland	New Zealand time
+NZ	-4357-17633	Pacific/Chatham	Chatham Islands
+PA,CA,KY	+0858-07932	America/Panama	EST - ON (Atikokan), NU (Coral H)
+PE	-1203-07703	America/Lima
+PF	-1732-14934	Pacific/Tahiti	Society Islands
+PF	-0900-13930	Pacific/Marquesas	Marquesas Islands
+PF	-2308-13457	Pacific/Gambier	Gambier Islands
+PG,AQ,FM	-0930+14710	Pacific/Port_Moresby	Papua New Guinea (most areas), Chuuk, Yap, Dumont d'Urville
+PG	-0613+15534	Pacific/Bougainville	Bougainville
+PH	+143512+1205804	Asia/Manila
+PK	+2452+06703	Asia/Karachi
+PL	+5215+02100	Europe/Warsaw
+PM	+4703-05620	America/Miquelon
+PN	-2504-13005	Pacific/Pitcairn
+PR,AG,CA,AI,AW,BL,BQ,CW,DM,GD,GP,KN,LC,MF,MS,SX,TT,VC,VG,VI	+182806-0660622	America/Puerto_Rico	AST - QC (Lower North Shore)
+PS	+3130+03428	Asia/Gaza	Gaza Strip
+PS	+313200+0350542	Asia/Hebron	West Bank
+PT	+3843-00908	Europe/Lisbon	Portugal (mainland)
+PT	+3238-01654	Atlantic/Madeira	Madeira Islands
+PT	+3744-02540	Atlantic/Azores	Azores
+PW	+0720+13429	Pacific/Palau
+PY	-2516-05740	America/Asuncion
+QA,BH	+2517+05132	Asia/Qatar
+RO	+4426+02606	Europe/Bucharest
+RS,BA,HR,ME,MK,SI	+4450+02030	Europe/Belgrade
+RU	+5443+02030	Europe/Kaliningrad	MSK-01 - Kaliningrad
+RU	+554521+0373704	Europe/Moscow	MSK+00 - Moscow area
+# Mention RU and UA alphabetically.  See "territorial claims" above.
+RU,UA	+4457+03406	Europe/Simferopol	Crimea
+RU	+5836+04939	Europe/Kirov	MSK+00 - Kirov
+RU	+4844+04425	Europe/Volgograd	MSK+00 - Volgograd
+RU	+4621+04803	Europe/Astrakhan	MSK+01 - Astrakhan
+RU	+5134+04602	Europe/Saratov	MSK+01 - Saratov
+RU	+5420+04824	Europe/Ulyanovsk	MSK+01 - Ulyanovsk
+RU	+5312+05009	Europe/Samara	MSK+01 - Samara, Udmurtia
+RU	+5651+06036	Asia/Yekaterinburg	MSK+02 - Urals
+RU	+5500+07324	Asia/Omsk	MSK+03 - Omsk
+RU	+5502+08255	Asia/Novosibirsk	MSK+04 - Novosibirsk
+RU	+5322+08345	Asia/Barnaul	MSK+04 - Altai
+RU	+5630+08458	Asia/Tomsk	MSK+04 - Tomsk
+RU	+5345+08707	Asia/Novokuznetsk	MSK+04 - Kemerovo
+RU	+5601+09250	Asia/Krasnoyarsk	MSK+04 - Krasnoyarsk area
+RU	+5216+10420	Asia/Irkutsk	MSK+05 - Irkutsk, Buryatia
+RU	+5203+11328	Asia/Chita	MSK+06 - Zabaykalsky
+RU	+6200+12940	Asia/Yakutsk	MSK+06 - Lena River
+RU	+623923+1353314	Asia/Khandyga	MSK+06 - Tomponsky, Ust-Maysky
+RU	+4310+13156	Asia/Vladivostok	MSK+07 - Amur River
+RU	+643337+1431336	Asia/Ust-Nera	MSK+07 - Oymyakonsky
+RU	+5934+15048	Asia/Magadan	MSK+08 - Magadan
+RU	+4658+14242	Asia/Sakhalin	MSK+08 - Sakhalin Island
+RU	+6728+15343	Asia/Srednekolymsk	MSK+08 - Sakha (E), N Kuril Is
+RU	+5301+15839	Asia/Kamchatka	MSK+09 - Kamchatka
+RU	+6445+17729	Asia/Anadyr	MSK+09 - Bering Sea
+SA,AQ,KW,YE	+2438+04643	Asia/Riyadh	Syowa
+SB,FM	-0932+16012	Pacific/Guadalcanal	Pohnpei
+SD	+1536+03232	Africa/Khartoum
+SG,AQ,MY	+0117+10351	Asia/Singapore	peninsular Malaysia, Concordia
+SR	+0550-05510	America/Paramaribo
+SS	+0451+03137	Africa/Juba
+ST	+0020+00644	Africa/Sao_Tome
+SV	+1342-08912	America/El_Salvador
+SY	+3330+03618	Asia/Damascus
+TC	+2128-07108	America/Grand_Turk
+TD	+1207+01503	Africa/Ndjamena
+TH,CX,KH,LA,VN	+1345+10031	Asia/Bangkok	north Vietnam
+TJ	+3835+06848	Asia/Dushanbe
+TK	-0922-17114	Pacific/Fakaofo
+TL	-0833+12535	Asia/Dili
+TM	+3757+05823	Asia/Ashgabat
+TN	+3648+01011	Africa/Tunis
+TO	-210800-1751200	Pacific/Tongatapu
+TR	+4101+02858	Europe/Istanbul
+TW	+2503+12130	Asia/Taipei
+UA	+5026+03031	Europe/Kyiv	most of Ukraine
+US	+404251-0740023	America/New_York	Eastern (most areas)
+US	+421953-0830245	America/Detroit	Eastern - MI (most areas)
+US	+381515-0854534	America/Kentucky/Louisville	Eastern - KY (Louisville area)
+US	+364947-0845057	America/Kentucky/Monticello	Eastern - KY (Wayne)
+US	+394606-0860929	America/Indiana/Indianapolis	Eastern - IN (most areas)
+US	+384038-0873143	America/Indiana/Vincennes	Eastern - IN (Da, Du, K, Mn)
+US	+410305-0863611	America/Indiana/Winamac	Eastern - IN (Pulaski)
+US	+382232-0862041	America/Indiana/Marengo	Eastern - IN (Crawford)
+US	+382931-0871643	America/Indiana/Petersburg	Eastern - IN (Pike)
+US	+384452-0850402	America/Indiana/Vevay	Eastern - IN (Switzerland)
+US	+415100-0873900	America/Chicago	Central (most areas)
+US	+375711-0864541	America/Indiana/Tell_City	Central - IN (Perry)
+US	+411745-0863730	America/Indiana/Knox	Central - IN (Starke)
+US	+450628-0873651	America/Menominee	Central - MI (Wisconsin border)
+US	+470659-1011757	America/North_Dakota/Center	Central - ND (Oliver)
+US	+465042-1012439	America/North_Dakota/New_Salem	Central - ND (Morton rural)
+US	+471551-1014640	America/North_Dakota/Beulah	Central - ND (Mercer)
+US	+394421-1045903	America/Denver	Mountain (most areas)
+US	+433649-1161209	America/Boise	Mountain - ID (south), OR (east)
+US,CA	+332654-1120424	America/Phoenix	MST - AZ (most areas), Creston BC
+US	+340308-1181434	America/Los_Angeles	Pacific
+US	+611305-1495401	America/Anchorage	Alaska (most areas)
+US	+581807-1342511	America/Juneau	Alaska - Juneau area
+US	+571035-1351807	America/Sitka	Alaska - Sitka area
+US	+550737-1313435	America/Metlakatla	Alaska - Annette Island
+US	+593249-1394338	America/Yakutat	Alaska - Yakutat
+US	+643004-1652423	America/Nome	Alaska (west)
+US	+515248-1763929	America/Adak	Alaska - western Aleutians
+US	+211825-1575130	Pacific/Honolulu	Hawaii
+UY	-345433-0561245	America/Montevideo
+UZ	+3940+06648	Asia/Samarkand	Uzbekistan (west)
+UZ	+4120+06918	Asia/Tashkent	Uzbekistan (east)
+VE	+1030-06656	America/Caracas
+VN	+1045+10640	Asia/Ho_Chi_Minh	south Vietnam
+VU	-1740+16825	Pacific/Efate
+WS	-1350-17144	Pacific/Apia
+ZA,LS,SZ	-2615+02800	Africa/Johannesburg
+#
+# The next section contains experimental tab-separated comments for
+# use by user agents like tzselect that identify continents and oceans.
+#
+# For example, the comment "#@AQAntarctica/" means the country code
+# AQ is in the continent Antarctica regardless of the Zone name,
+# so Pacific/Auckland should be listed under Antarctica as well as
+# under the Pacific because its line's country codes include AQ.
+#
+# If more than one country code is affected each is listed separated
+# by commas, e.g., #@IS,SHAtlantic/".  If a country code is in
+# more than one continent or ocean, each is listed separated by
+# commas, e.g., the second column of "#@CY,TRAsia/,Europe/".
+#
+# These experimental comments are present only for country codes where
+# the continent or ocean is not already obvious from the Zone name.
+# For example, there is no such comment for RU since it already
+# corresponds to Zone names starting with both "Europe/" and "Asia/".
+#
+#@AQ	Antarctica/
+#@IS,SH	Atlantic/
+#@CY,TR	Asia/,Europe/
+#@SJ	Arctic/
+#@CC,CX,KM,MG,YT	Indian/
diff --git a/marketing/share/zoneinfo/zonenow.tab b/marketing/share/zoneinfo/zonenow.tab
new file mode 100644
index 0000000000000000000000000000000000000000..d2c1e48584f8f8f5d7a0e48ead4e557490d4197f
--- /dev/null
+++ b/marketing/share/zoneinfo/zonenow.tab
@@ -0,0 +1,296 @@
+# tzdb timezone descriptions, for users who do not care about old timestamps
+#
+# This file is in the public domain.
+#
+# From Paul Eggert (2023-12-18):
+# This file contains a table where each row stands for a timezone
+# where civil timestamps are predicted to agree from now on.
+# This file is like zone1970.tab (see zone1970.tab's comments),
+# but with the following changes:
+#
+# 1.  Each timezone corresponds to a set of clocks that are planned
+#     to agree from now on.  This is a larger set of clocks than in
+#     zone1970.tab, where each timezone's clocks must agree from 1970 on.
+# 2.  The first column is irrelevant and ignored.
+# 3.  The table is sorted in a different way:
+#     first by standard time UTC offset;
+#     then, if DST is used, by daylight saving UTC offset;
+#     then by time zone abbreviation.
+# 4.  Every timezone has a nonempty comments column, with wording
+#     distinguishing the timezone only from other timezones with the
+#     same UTC offset at some point during the year.
+#
+# The format of this table is experimental, and may change in future versions.
+#
+# This table is intended as an aid for users, to help them select timezones
+# appropriate for their practical needs.  It is not intended to take or
+# endorse any position on legal or territorial claims.
+#
+#XX	coordinates	TZ	comments
+#
+# -11 - SST
+XX	-1416-17042	Pacific/Pago_Pago	Midway; Samoa ("SST")
+#
+# -11
+XX	-1901-16955	Pacific/Niue	Niue
+#
+# -10 - HST
+XX	+211825-1575130	Pacific/Honolulu	Hawaii ("HST")
+#
+# -10
+XX	-1732-14934	Pacific/Tahiti	Tahiti; Cook Islands
+#
+# -10/-09 - HST / HDT (North America DST)
+XX	+515248-1763929	America/Adak	western Aleutians in Alaska ("HST/HDT")
+#
+# -09:30
+XX	-0900-13930	Pacific/Marquesas	Marquesas
+#
+# -09
+XX	-2308-13457	Pacific/Gambier	Gambier
+#
+# -09/-08 - AKST/AKDT (North America DST)
+XX	+611305-1495401	America/Anchorage	most of Alaska ("AKST/AKDT")
+#
+# -08
+XX	-2504-13005	Pacific/Pitcairn	Pitcairn
+#
+# -08/-07 - PST/PDT (North America DST)
+XX	+340308-1181434	America/Los_Angeles	Pacific ("PST/PDT") - US & Canada; Mexico near US border
+#
+# -07 - MST
+XX	+332654-1120424	America/Phoenix	Mountain Standard ("MST") - Arizona; western Mexico; Yukon
+#
+# -07/-06 - MST/MDT (North America DST)
+XX	+394421-1045903	America/Denver	Mountain ("MST/MDT") - US & Canada; Mexico near US border
+#
+# -06
+XX	-0054-08936	Pacific/Galapagos	Galápagos
+#
+# -06 - CST
+XX	+1924-09909	America/Mexico_City	Central Standard ("CST") - Saskatchewan; central Mexico; Central America
+#
+# -06/-05 (Chile DST)
+XX	-2709-10926	Pacific/Easter	Easter Island
+#
+# -06/-05 - CST/CDT (North America DST)
+XX	+415100-0873900	America/Chicago	Central ("CST/CDT") - US & Canada; Mexico near US border
+#
+# -05
+XX	-1203-07703	America/Lima	eastern South America
+#
+# -05 - EST
+XX	+175805-0764736	America/Jamaica	Eastern Standard ("EST") - Caymans; Jamaica; eastern Mexico; Panama
+#
+# -05/-04 - CST/CDT (Cuba DST)
+XX	+2308-08222	America/Havana	Cuba
+#
+# -05/-04 - EST/EDT (North America DST)
+XX	+404251-0740023	America/New_York	Eastern ("EST/EDT") - US & Canada
+#
+# -04
+XX	+1030-06656	America/Caracas	western South America
+#
+# -04 - AST
+XX	+1828-06954	America/Santo_Domingo	Atlantic Standard ("AST") - eastern Caribbean
+#
+# -04/-03 (Chile DST)
+XX	-3327-07040	America/Santiago	most of Chile
+#
+# -04/-03 - AST/ADT (North America DST)
+XX	+4439-06336	America/Halifax	Atlantic ("AST/ADT") - Canada; Bermuda
+#
+# -03:30/-02:30 - NST/NDT (North America DST)
+XX	+4734-05243	America/St_Johns	Newfoundland ("NST/NDT")
+#
+# -03
+XX	-2332-04637	America/Sao_Paulo	eastern South America
+#
+# -03/-02 (North America DST)
+XX	+4703-05620	America/Miquelon	St Pierre & Miquelon
+#
+# -02
+XX	-0351-03225	America/Noronha	Fernando de Noronha; South Georgia
+#
+# -02/-01 (EU DST)
+XX	+6411-05144	America/Nuuk	most of Greenland
+#
+# -01
+XX	+1455-02331	Atlantic/Cape_Verde	Cape Verde
+#
+# -01/+00 (EU DST)
+XX	+3744-02540	Atlantic/Azores	Azores
+#
+# +00 - GMT
+XX	+0519-00402	Africa/Abidjan	far western Africa; Iceland ("GMT")
+#
+# +00/+01 - GMT/BST (EU DST)
+XX	+513030-0000731	Europe/London	United Kingdom ("GMT/BST")
+#
+# +00/+01 - WET/WEST (EU DST)
+XX	+3843-00908	Europe/Lisbon	western Europe ("WET/WEST")
+#
+# +00/+02 - Troll DST
+XX	-720041+0023206	Antarctica/Troll	Troll Station in Antarctica
+#
+# +01 - CET
+XX	+3647+00303	Africa/Algiers	Algeria, Tunisia ("CET")
+#
+# +01 - WAT
+XX	+0627+00324	Africa/Lagos	western Africa ("WAT")
+#
+# +01/+00 - IST/GMT (EU DST in reverse)
+XX	+5320-00615	Europe/Dublin	Ireland ("IST/GMT")
+#
+# +01/+00 - (Morocco DST)
+XX	+3339-00735	Africa/Casablanca	Morocco
+#
+# +01/+02 - CET/CEST (EU DST)
+XX	+4852+00220	Europe/Paris	central Europe ("CET/CEST")
+#
+# +02 - CAT
+XX	-2558+03235	Africa/Maputo	central Africa ("CAT")
+#
+# +02 - EET
+XX	+3254+01311	Africa/Tripoli	Libya; Kaliningrad ("EET")
+#
+# +02 - SAST
+XX	-2615+02800	Africa/Johannesburg	southern Africa ("SAST")
+#
+# +02/+03 - EET/EEST (EU DST)
+XX	+3758+02343	Europe/Athens	eastern Europe ("EET/EEST")
+#
+# +02/+03 - EET/EEST (Egypt DST)
+XX	+3003+03115	Africa/Cairo	Egypt
+#
+# +02/+03 - EET/EEST (Lebanon DST)
+XX	+3353+03530	Asia/Beirut	Lebanon
+#
+# +02/+03 - EET/EEST (Moldova DST)
+XX	+4700+02850	Europe/Chisinau	Moldova
+#
+# +02/+03 - EET/EEST (Palestine DST)
+XX	+3130+03428	Asia/Gaza	Palestine
+#
+# +02/+03 - IST/IDT (Israel DST)
+XX	+314650+0351326	Asia/Jerusalem	Israel
+#
+# +03
+XX	+4101+02858	Europe/Istanbul	Near East; Belarus
+#
+# +03 - EAT
+XX	-0117+03649	Africa/Nairobi	eastern Africa ("EAT")
+#
+# +03 - MSK
+XX	+554521+0373704	Europe/Moscow	Moscow ("MSK")
+#
+# +03:30
+XX	+3540+05126	Asia/Tehran	Iran
+#
+# +04
+XX	+2518+05518	Asia/Dubai	Russia; Caucasus; Persian Gulf; Seychelles; Réunion
+#
+# +04:30
+XX	+3431+06912	Asia/Kabul	Afghanistan
+#
+# +05
+XX	+4120+06918	Asia/Tashkent	Russia; Kazakhstan; Tajikistan; Turkmenistan; Uzbekistan; Maldives
+#
+# +05 - PKT
+XX	+2452+06703	Asia/Karachi	Pakistan ("PKT")
+#
+# +05:30
+XX	+0656+07951	Asia/Colombo	Sri Lanka
+#
+# +05:30 - IST
+XX	+2232+08822	Asia/Kolkata	India ("IST")
+#
+# +05:45
+XX	+2743+08519	Asia/Kathmandu	Nepal
+#
+# +06
+XX	+2343+09025	Asia/Dhaka	Russia; Kyrgyzstan; Bhutan; Bangladesh; Chagos
+#
+# +06:30
+XX	+1647+09610	Asia/Yangon	Myanmar; Cocos
+#
+# +07
+XX	+1345+10031	Asia/Bangkok	Russia; Indochina; Christmas Island
+#
+# +07 - WIB
+XX	-0610+10648	Asia/Jakarta	Indonesia ("WIB")
+#
+# +08
+XX	+0117+10351	Asia/Singapore	Russia; Brunei; Malaysia; Singapore; Concordia
+#
+# +08 - AWST
+XX	-3157+11551	Australia/Perth	Western Australia ("AWST")
+#
+# +08 - CST
+XX	+3114+12128	Asia/Shanghai	China ("CST")
+#
+# +08 - HKT
+XX	+2217+11409	Asia/Hong_Kong	Hong Kong ("HKT")
+#
+# +08 - PHT
+XX	+143512+1205804	Asia/Manila	Philippines ("PHT")
+#
+# +08 - WITA
+XX	-0507+11924	Asia/Makassar	Indonesia ("WITA")
+#
+# +08:45
+XX	-3143+12852	Australia/Eucla	Eucla
+#
+# +09
+XX	+5203+11328	Asia/Chita	Russia; Palau; East Timor
+#
+# +09 - JST
+XX	+353916+1394441	Asia/Tokyo	Japan ("JST"); Eyre Bird Observatory
+#
+# +09 - KST
+XX	+3733+12658	Asia/Seoul	Korea ("KST")
+#
+# +09 - WIT
+XX	-0232+14042	Asia/Jayapura	Indonesia ("WIT")
+#
+# +09:30 - ACST
+XX	-1228+13050	Australia/Darwin	Northern Territory ("ACST")
+#
+# +09:30/+10:30 - ACST/ACDT (Australia DST)
+XX	-3455+13835	Australia/Adelaide	South Australia ("ACST/ACDT")
+#
+# +10
+XX	+4310+13156	Asia/Vladivostok	Russia; Yap; Chuuk; Papua New Guinea; Dumont d'Urville
+#
+# +10 - AEST
+XX	-2728+15302	Australia/Brisbane	Queensland ("AEST")
+#
+# +10 - ChST
+XX	+1328+14445	Pacific/Guam	Mariana Islands ("ChST")
+#
+# +10/+11 - AEST/AEDT (Australia DST)
+XX	-3352+15113	Australia/Sydney	southeast Australia ("AEST/AEDT")
+#
+# +10:30/+11
+XX	-3133+15905	Australia/Lord_Howe	Lord Howe Island
+#
+# +11
+XX	-0613+15534	Pacific/Bougainville	Russia; Kosrae; Bougainville; Solomons
+#
+# +11/+12 (Australia DST)
+XX	-2903+16758	Pacific/Norfolk	Norfolk Island
+#
+# +12
+XX	+5301+15839	Asia/Kamchatka	Russia; Tuvalu; Fiji; etc.
+#
+# +12/+13 (New Zealand DST)
+XX	-3652+17446	Pacific/Auckland	New Zealand ("NZST/NZDT")
+#
+# +12:45/+13:45 (Chatham DST)
+XX	-4357-17633	Pacific/Chatham	Chatham Islands
+#
+# +13
+XX	-210800-1751200	Pacific/Tongatapu	Kanton; Tokelau; Samoa (western); Tonga
+#
+# +14
+XX	+0152-15720	Pacific/Kiritimati	Kiritimati
diff --git a/marketing/vcruntime140_1.dll b/marketing/vcruntime140_1.dll
new file mode 100644
index 0000000000000000000000000000000000000000..8ad4c3b724f93617e8f657e7c81265a9e9bf3823
Binary files /dev/null and b/marketing/vcruntime140_1.dll differ
diff --git a/marketing/vcruntime140_threads.dll b/marketing/vcruntime140_threads.dll
new file mode 100644
index 0000000000000000000000000000000000000000..1e22f566a7af26e61ca8e6bf19ae0cb5fa0be04e
Binary files /dev/null and b/marketing/vcruntime140_threads.dll differ
diff --git a/params.yaml b/params.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..109739b6993859c63870039aab7832887857bc62
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,16 @@
+pymongo                      # MongoDB connector
+python-dotenv                # Load secrets from .env
+pandas                       # For data handling
+pydantic                     # For schema validation
+requests                     # If pulling data from APIs
+openai                       # LLMs if used for text generation
+langchain                   # For chaining LLM tasks
+streamlit                   # Frontend
+fastapi                     # Backend
+uvicorn                     # API server
+pyyaml                      # Config loader
+loguru         
+chromadb
+sentence-transformers
+langchain
+langchain-community
diff --git a/research/research.ipynb b/research/research.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/__init__.py b/src/marketingCampaignGen/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/__pycache__/__init__.cpython-310.pyc b/src/marketingCampaignGen/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..04a9a13cb244c78d6f680e5ba6334706a032a0c4
Binary files /dev/null and b/src/marketingCampaignGen/__pycache__/__init__.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/__pycache__/__init__.cpython-37.pyc b/src/marketingCampaignGen/__pycache__/__init__.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..498a5a64917340e487b2d09dea5e737501186f0c
Binary files /dev/null and b/src/marketingCampaignGen/__pycache__/__init__.cpython-37.pyc differ
diff --git a/src/marketingCampaignGen/__pycache__/__init__.cpython-38.pyc b/src/marketingCampaignGen/__pycache__/__init__.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..757320bc73fb26d1c786b5ffb61d45a119990c64
Binary files /dev/null and b/src/marketingCampaignGen/__pycache__/__init__.cpython-38.pyc differ
diff --git a/src/marketingCampaignGen/components/__init__.py b/src/marketingCampaignGen/components/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/components/__pycache__/__init__.cpython-310.pyc b/src/marketingCampaignGen/components/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c8cfda71de69d256335d42d7c15e8918565a3beb
Binary files /dev/null and b/src/marketingCampaignGen/components/__pycache__/__init__.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/components/__pycache__/__init__.cpython-37.pyc b/src/marketingCampaignGen/components/__pycache__/__init__.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f661820cfc726e1dc5dd79ad30f79d81f77a0470
Binary files /dev/null and b/src/marketingCampaignGen/components/__pycache__/__init__.cpython-37.pyc differ
diff --git a/src/marketingCampaignGen/components/__pycache__/__init__.cpython-38.pyc b/src/marketingCampaignGen/components/__pycache__/__init__.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e75c13f0bde347cbe711459044f1c2f1a150601e
Binary files /dev/null and b/src/marketingCampaignGen/components/__pycache__/__init__.cpython-38.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/__init__.py b/src/marketingCampaignGen/components/etl/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/components/etl/__pycache__/__init__.cpython-310.pyc b/src/marketingCampaignGen/components/etl/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..80b27dfe681fe6c6bf286c0444e8ffad224f9a56
Binary files /dev/null and b/src/marketingCampaignGen/components/etl/__pycache__/__init__.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/__pycache__/__init__.cpython-37.pyc b/src/marketingCampaignGen/components/etl/__pycache__/__init__.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f124a3c60dc7cbc2692e86d9591b2bbd7550909
Binary files /dev/null and b/src/marketingCampaignGen/components/etl/__pycache__/__init__.cpython-37.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/__pycache__/__init__.cpython-38.pyc b/src/marketingCampaignGen/components/etl/__pycache__/__init__.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fad04ef10a6599bfb0325d2d9adb2b7d321b5b77
Binary files /dev/null and b/src/marketingCampaignGen/components/etl/__pycache__/__init__.cpython-38.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/__pycache__/etl.cpython-310.pyc b/src/marketingCampaignGen/components/etl/__pycache__/etl.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d1d2d6e6e8e0a11ec3ab248d2b6a6ff3a3af1d01
Binary files /dev/null and b/src/marketingCampaignGen/components/etl/__pycache__/etl.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/__pycache__/etl.cpython-37.pyc b/src/marketingCampaignGen/components/etl/__pycache__/etl.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e6ea10089f5825550168d44df4e87dee0f3bfea
Binary files /dev/null and b/src/marketingCampaignGen/components/etl/__pycache__/etl.cpython-37.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/__pycache__/etl.cpython-38.pyc b/src/marketingCampaignGen/components/etl/__pycache__/etl.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05d1574d862bf0a29c072f9a6b3dbe096bdb8cd7
Binary files /dev/null and b/src/marketingCampaignGen/components/etl/__pycache__/etl.cpython-38.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/__pycache__/mongo_connector.cpython-310.pyc b/src/marketingCampaignGen/components/etl/__pycache__/mongo_connector.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dc0308ce5dbfb6bf431d02f582009606518a9f87
Binary files /dev/null and b/src/marketingCampaignGen/components/etl/__pycache__/mongo_connector.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/__pycache__/mongo_connector.cpython-37.pyc b/src/marketingCampaignGen/components/etl/__pycache__/mongo_connector.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f2bb269ff14ff7ba559785d199ce6b65dad7816
Binary files /dev/null and b/src/marketingCampaignGen/components/etl/__pycache__/mongo_connector.cpython-37.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/__pycache__/mongo_connector.cpython-38.pyc b/src/marketingCampaignGen/components/etl/__pycache__/mongo_connector.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c690ed0fd517cd552fbef141797101caa6520842
Binary files /dev/null and b/src/marketingCampaignGen/components/etl/__pycache__/mongo_connector.cpython-38.pyc differ
diff --git a/src/marketingCampaignGen/components/etl/config.py b/src/marketingCampaignGen/components/etl/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/components/etl/etl.py b/src/marketingCampaignGen/components/etl/etl.py
new file mode 100644
index 0000000000000000000000000000000000000000..c99364d4e89167ca96dd4d122f9fe2df68b5339c
--- /dev/null
+++ b/src/marketingCampaignGen/components/etl/etl.py
@@ -0,0 +1,46 @@
+from datetime import datetime
+import uuid
+from src.marketingCampaignGen.components.etl.mongo_connector import store_to_mongo
+from src.marketingCampaignGen.utils.vector_store import add_to_vectorstore
+
+class ETLPipeline:
+    def __init__(self, raw_input: dict):
+        self.raw_input = raw_input
+
+    def clean_input(self) -> dict:
+        return {
+            "id": str(uuid.uuid4()),
+            "timestamp": datetime.utcnow().isoformat(),  # Still a valid string now
+            "product_name": self.raw_input.get("product_name", "").strip(),
+            "features": ", ".join(f.strip() for f in self.raw_input.get("features", [])),  #  FIXED
+            "brand": self.raw_input.get("brand", "").strip(),
+            "audience": self.raw_input.get("audience", "").strip(),
+            "tone": self.raw_input.get("tone", "").lower(),
+            "goal": self.raw_input.get("goal", "").strip(),
+        }
+
+
+    def run(self, return_data=False):
+        print("[ETL] Starting pipeline...")
+        cleaned = self.clean_input()
+        print("[ETL] Cleaned Data:", cleaned)
+        store_to_mongo(cleaned)
+        add_to_vectorstore(cleaned)
+        print("[ETL] Done.")
+        if return_data:
+            return cleaned
+
+
+# ----------------------
+# Entry point
+if __name__ == "__main__":
+    sample_input = {
+        "product_name": "EcoSip Water Bottle",
+        "features": ["Eco-friendly", "BPA-free", "Keeps water cold for 24 hours"],
+        "brand": "EcoSip",
+        "audience": "Fitness Enthusiasts",
+        "tone": "Friendly",
+        "goal": "Increase brand awareness"
+    }
+    pipeline = ETLPipeline(sample_input)
+    pipeline.run()
diff --git a/src/marketingCampaignGen/components/etl/mongo_connector.py b/src/marketingCampaignGen/components/etl/mongo_connector.py
new file mode 100644
index 0000000000000000000000000000000000000000..11ffecad00908e0444ab6e7dbbeda087e64a4ad8
--- /dev/null
+++ b/src/marketingCampaignGen/components/etl/mongo_connector.py
@@ -0,0 +1,11 @@
+from pymongo import MongoClient
+
+def store_to_mongo(data, mongo_uri="mongodb://localhost:27017", db_name="db_main"):
+    try:
+        client = MongoClient(mongo_uri)
+        db = client[db_name]
+        result = db["campaign_inputs"].insert_one(data)
+        print(f"[MongoDB] Inserted ID: {result.inserted_id}")
+    except Exception as e:
+        print(f"[MongoDB] Error: {e}")
+
diff --git a/src/marketingCampaignGen/components/etl/schema.py b/src/marketingCampaignGen/components/etl/schema.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/components/etl/utils.py b/src/marketingCampaignGen/components/etl/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/components/model/__init__.py b/src/marketingCampaignGen/components/model/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/components/model/__pycache__/__init__.cpython-310.pyc b/src/marketingCampaignGen/components/model/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f479d8a42064145aac353a88574feef9fb686e3
Binary files /dev/null and b/src/marketingCampaignGen/components/model/__pycache__/__init__.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/components/model/__pycache__/__init__.cpython-37.pyc b/src/marketingCampaignGen/components/model/__pycache__/__init__.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3d643a41f00cce07da4160cde8186bff9d0abf41
Binary files /dev/null and b/src/marketingCampaignGen/components/model/__pycache__/__init__.cpython-37.pyc differ
diff --git a/src/marketingCampaignGen/components/model/__pycache__/generator.cpython-310.pyc b/src/marketingCampaignGen/components/model/__pycache__/generator.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b17721832cef06197044ff1325e85778c46b87e4
Binary files /dev/null and b/src/marketingCampaignGen/components/model/__pycache__/generator.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/components/model/__pycache__/predictor.cpython-310.pyc b/src/marketingCampaignGen/components/model/__pycache__/predictor.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ba64a4e2bfddf9f1241234289ffa0749209b9be
Binary files /dev/null and b/src/marketingCampaignGen/components/model/__pycache__/predictor.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/components/model/__pycache__/predictor.cpython-37.pyc b/src/marketingCampaignGen/components/model/__pycache__/predictor.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d61acd26b428c5bcb79314f7434128738853023b
Binary files /dev/null and b/src/marketingCampaignGen/components/model/__pycache__/predictor.cpython-37.pyc differ
diff --git a/src/marketingCampaignGen/components/model/generator.py b/src/marketingCampaignGen/components/model/generator.py
new file mode 100644
index 0000000000000000000000000000000000000000..329cdd1d74ec87489df1c7b84ed9566cedaa86d1
--- /dev/null
+++ b/src/marketingCampaignGen/components/model/generator.py
@@ -0,0 +1,56 @@
+# src/marketingCampaignGen/utils/campaign_generator.py
+
+
+from langchain.llms import Ollama
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from src.marketingCampaignGen.utils.vector_store import get_similar_examples
+
+
+class CampaignGenerator:
+    def __init__(self, model_name="mistral"):
+        self.llm = Ollama(model=model_name)
+
+        self.template = PromptTemplate(
+            input_variables=["product_name", "features", "brand", "audience", "tone", "goal", "examples"],
+            template="""
+You are an expert marketing copywriter.
+
+Here are some examples of previous campaigns:
+{examples}
+
+Now, based on the following input, write a compelling campaign message:
+- Product: {product_name}
+- Features: {features}
+- Brand: {brand}
+- Target Audience: {audience}
+- Tone: {tone}
+- Goal: {goal}
+
+Write the campaign in the specified tone and make it persuasive.
+"""
+        )
+
+        self.chain = LLMChain(llm=self.llm, prompt=self.template)
+
+    def generate(self, input_data: dict) -> str:
+        feature_query = ", ".join(input_data["features"])
+        examples = get_similar_examples(feature_query, top_k=2)
+
+        # Flatten list of documents
+        flat_examples = [doc for sublist in examples["documents"] for doc in sublist]
+        example_text = "\n\n".join(flat_examples) if flat_examples else "None"
+
+        response = self.chain.run(
+            product_name=input_data["product_name"],
+            features=feature_query,
+            brand=input_data["brand"],
+            audience=input_data["audience"],
+            tone=input_data["tone"],
+            goal=input_data["goal"],
+            examples=example_text
+        )
+
+        return response
+
+
diff --git a/src/marketingCampaignGen/components/model/predictor.py b/src/marketingCampaignGen/components/model/predictor.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ca6b224f5c0dbfcae49b1a6cdae090f8b8cc376
--- /dev/null
+++ b/src/marketingCampaignGen/components/model/predictor.py
@@ -0,0 +1,24 @@
+# Directory: src/marketingCampaignGen/backend/llm_predictor.py
+from src.marketingCampaignGen.utils.vector_store import get_context
+
+
+from src.marketingCampaignGen.components.model.generator import CampaignGenerator
+
+
+class LLMPredictionPipeline:
+    def __init__(self, model_name: str = "mistral"):
+        # Initialize the CampaignGenerator with the selected LLM model
+        self.generator = CampaignGenerator(model_name)
+
+    def predict(self, cleaned_input: dict) -> str:
+        """
+        Predict/generate a campaign message using the CampaignGenerator class.
+
+        Args:
+            cleaned_input (dict): Preprocessed product data from user or ETL.
+
+        Returns:
+            str: Generated campaign content from the LLM.
+        """
+        return self.generator.generate(cleaned_input)
+
diff --git a/src/marketingCampaignGen/config/__init__.py b/src/marketingCampaignGen/config/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/config/configuration.py b/src/marketingCampaignGen/config/configuration.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/constants/__init__.py b/src/marketingCampaignGen/constants/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/entity/__init__.py b/src/marketingCampaignGen/entity/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/logging/__init__.py b/src/marketingCampaignGen/logging/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/pipeline/__init__.py b/src/marketingCampaignGen/pipeline/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/pipeline/data_pipeline.py b/src/marketingCampaignGen/pipeline/data_pipeline.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/pipeline/predict_pipeline.py b/src/marketingCampaignGen/pipeline/predict_pipeline.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/utils/__init__.py b/src/marketingCampaignGen/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/utils/__pycache__/__init__.cpython-310.pyc b/src/marketingCampaignGen/utils/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fe8199221c08bfde3a046fff1d62a59c587c3959
Binary files /dev/null and b/src/marketingCampaignGen/utils/__pycache__/__init__.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/utils/__pycache__/__init__.cpython-37.pyc b/src/marketingCampaignGen/utils/__pycache__/__init__.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6aa8c975540fdd973bc3cbfc2228757b87259e36
Binary files /dev/null and b/src/marketingCampaignGen/utils/__pycache__/__init__.cpython-37.pyc differ
diff --git a/src/marketingCampaignGen/utils/__pycache__/__init__.cpython-38.pyc b/src/marketingCampaignGen/utils/__pycache__/__init__.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c45ddab37472d496e5155b75f229c161c9fb8a72
Binary files /dev/null and b/src/marketingCampaignGen/utils/__pycache__/__init__.cpython-38.pyc differ
diff --git a/src/marketingCampaignGen/utils/__pycache__/vector_store.cpython-310.pyc b/src/marketingCampaignGen/utils/__pycache__/vector_store.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3f958d11d2412d4ffaef14245ea01b9e279ceb45
Binary files /dev/null and b/src/marketingCampaignGen/utils/__pycache__/vector_store.cpython-310.pyc differ
diff --git a/src/marketingCampaignGen/utils/__pycache__/vector_store.cpython-37.pyc b/src/marketingCampaignGen/utils/__pycache__/vector_store.cpython-37.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..50ca69b65fa459541d829d59d4835221cc635a11
Binary files /dev/null and b/src/marketingCampaignGen/utils/__pycache__/vector_store.cpython-37.pyc differ
diff --git a/src/marketingCampaignGen/utils/__pycache__/vector_store.cpython-38.pyc b/src/marketingCampaignGen/utils/__pycache__/vector_store.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..471817b619a830848c68ea8312ff33cade5750ce
Binary files /dev/null and b/src/marketingCampaignGen/utils/__pycache__/vector_store.cpython-38.pyc differ
diff --git a/src/marketingCampaignGen/utils/common.py b/src/marketingCampaignGen/utils/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/marketingCampaignGen/utils/vector_store.py b/src/marketingCampaignGen/utils/vector_store.py
new file mode 100644
index 0000000000000000000000000000000000000000..be78c32791d9d6db33a8c981b5cf4315a3619cfb
--- /dev/null
+++ b/src/marketingCampaignGen/utils/vector_store.py
@@ -0,0 +1,61 @@
+# src/marketingCampaignGen/utils/vector_store.py
+
+import chromadb
+from sentence_transformers import SentenceTransformer
+from chromadb.utils import embedding_functions
+
+CHROMA_PATH = "chroma_db"
+COLLECTION_NAME = "marketing_campaigns"
+
+#  Use the new PersistentClient (no Settings needed)
+client = chromadb.PersistentClient(path=CHROMA_PATH)
+
+#  Define embedding function using SentenceTransformer
+embedding_func = embedding_functions.SentenceTransformerEmbeddingFunction(
+    model_name="all-MiniLM-L6-v2"
+)
+
+#  Create or get collection with embedding function
+collection = client.get_or_create_collection(
+    name=COLLECTION_NAME,
+    embedding_function=embedding_func
+)
+
+def add_to_vectorstore(data: dict):
+    #  Ensure metadata only has valid types (str, int, float, bool)
+    metadata = {
+        k: v for k, v in data.items()
+        if isinstance(v, (str, int, float, bool))
+    }
+
+    document_text = f"{data['product_name']} - {data['features']} - {data['goal']}"
+
+    #  Add document to vector DB
+    collection.add(
+        documents=[document_text],
+        metadatas=[metadata],
+        ids=[data["id"]]  # ensure this is a UUID string
+    )
+
+    print(f"[VectorDB] Document added with ID: {data['id']}")
+def get_context(query: str, top_k: int = 1) -> str:
+    """
+    Performs a similarity search on the vector DB using the query
+    and returns the top_k most relevant context strings.
+    """
+    results = collection.query(
+        query_texts=[query],
+        n_results=top_k
+    )
+
+    # Get the top result's document text
+    docs = results.get("documents", [[]])[0]
+    return " ".join(docs) if docs else "No relevant context found."
+
+def get_similar_examples(query: str, top_k: int = 3):
+    results = collection.query(
+        query_texts=[query],
+        n_results=top_k
+    )
+    return results
+
diff --git a/streamlit_app.py b/streamlit_app.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c15866b70243a8604e6d5a8f16ada59218eb233
--- /dev/null
+++ b/streamlit_app.py
@@ -0,0 +1,43 @@
+# streamlit_app.py
+import streamlit as st
+import requests
+import json
+
+st.set_page_config(page_title="LLM Marketing Campaign Generator", layout="centered")
+st.title("📣 Marketing Campaign Generator")
+
+st.markdown("Enter your product details below to generate a custom marketing campaign using AI.")
+
+# --- Input fields ---
+product_name = st.text_input("Product Name", "EcoSip Water Bottle")
+features = st.text_area("Features (comma-separated)", "Eco-friendly, BPA-free, Keeps water cold for 24 hours")
+brand = st.text_input("Brand", "EcoSip")
+audience = st.text_input("Target Audience", "Fitness Enthusiasts")
+tone = st.selectbox("Tone", ["friendly", "professional", "luxurious", "humorous"])
+goal = st.text_input("Campaign Goal", "Increase brand awareness")
+
+# --- Submit button ---
+if st.button("🚀 Generate Campaign"):
+    try:
+        # Prepare request payload
+        payload = {
+            "product_name": product_name,
+            "features": [f.strip() for f in features.split(",")],
+            "brand": brand,
+            "audience": audience,
+            "tone": tone,
+            "goal": goal
+        }
+
+        # Call FastAPI backend
+        response = requests.post("http://localhost:8000/generate", json=payload)
+
+        if response.status_code == 200:
+            campaign = response.json()["campaign"]
+            st.subheader("📝 Generated Campaign")
+            st.success(campaign)
+        else:
+            st.error(f"Error: {response.status_code} - {response.text}")
+
+    except Exception as e:
+        st.error(f"Exception: {e}")
diff --git a/template.py b/template.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4d548b772f50e92971075061b18695196beb665
--- /dev/null
+++ b/template.py
@@ -0,0 +1,55 @@
+import os
+from pathlib import Path
+import logging
+
+logging.basicConfig(level=logging.INFO, format='[%(asctime)s]: %(message)s:')
+
+project_name = "marketingCampaignGen"
+
+list_of_files = [
+    ".github/workflows/.gitkeep",
+    f"src/{project_name}/__init__.py",
+    f"src/{project_name}/components/__init__.py",
+    f"src/{project_name}/components/etl/__init__.py",
+    f"src/{project_name}/components/etl/config.py",
+    f"src/{project_name}/components/etl/mongo_connector.py",
+    f"src/{project_name}/components/etl/etl.py",
+    f"src/{project_name}/components/etl/schema.py",
+    f"src/{project_name}/components/etl/utils.py",
+    f"src/{project_name}/components/model/__init__.py",
+    f"src/{project_name}/components/model/generator.py",
+    f"src/{project_name}/components/model/predictor.py",
+    f"src/{project_name}/utils/__init__.py",
+    f"src/{project_name}/utils/common.py",
+    f"src/{project_name}/logging/__init__.py",
+    f"src/{project_name}/config/__init__.py",
+    f"src/{project_name}/config/configuration.py",
+    f"src/{project_name}/pipeline/__init__.py",
+    f"src/{project_name}/pipeline/data_pipeline.py",
+    f"src/{project_name}/pipeline/predict_pipeline.py",
+    f"src/{project_name}/entity/__init__.py",
+    f"src/{project_name}/constants/__init__.py",
+    "config/config.yaml",
+    "params.yaml",
+    "app.py",
+    "main.py",
+    "Dockerfile",
+    "requirements.txt",
+    "setup.py",
+    "research/research.ipynb"
+]
+
+for filepath in list_of_files:
+    filepath = Path(filepath)
+    filedir, filename = os.path.split(filepath)
+
+    if filedir != "":
+        os.makedirs(filedir, exist_ok=True)
+        logging.info(f"Creating directory: {filedir} for the file {filename}")
+
+    if (not os.path.exists(filepath)) or (os.path.getsize(filepath) == 0):
+        with open(filepath, 'w') as f:
+            pass
+        logging.info(f"Creating empty file: {filepath}")
+    else:
+        logging.info(f"{filename} already exists")